静的ファイル - StaticFiles

StaticFilesクラスを使用して、JavaScript、CSS、画像などの静的ファイルを配信できます。

静的ファイルに関するFastAPIドキュメントで詳細を確認してください。

fastapi.staticfilesから直接インポートできます。

from fastapi.staticfiles import StaticFiles

fastapi.staticfiles.StaticFiles

StaticFiles(
    *,
    directory=None,
    packages=None,
    html=False,
    check_dir=True,
    follow_symlink=False
)

パラメータ	説明
directory	型: PathLike | None デフォルト: None
packages	型: list[str | tuple[str, str]] | None デフォルト: None
html	型: bool デフォルト: False
check_dir	型: bool デフォルト: True
follow_symlink	型: bool デフォルト: False

starlette/staticfiles.pyのソースコード

def __init__(
    self,
    *,
    directory: PathLike | None = None,
    packages: list[str | tuple[str, str]] | None = None,
    html: bool = False,
    check_dir: bool = True,
    follow_symlink: bool = False,
) -> None:
    self.directory = directory
    self.packages = packages
    self.all_directories = self.get_directories(directory, packages)
    self.html = html
    self.config_checked = False
    self.follow_symlink = follow_symlink
    if check_dir and directory is not None and not os.path.isdir(directory):
        raise RuntimeError(f"Directory '{directory}' does not exist")

directory インスタンス属性

directory = directory

packages インスタンス属性

packages = packages

all_directories インスタンス属性

all_directories = get_directories(directory, packages)

html インスタンス属性

html = html

config_checked インスタンス属性

config_checked = False

follow_symlink インスタンス属性

follow_symlink = follow_symlink

get_directories

get_directories(directory=None, packages=None)

directory引数とpackages引数を指定して、静的ファイルを配信するために使用するすべてのディレクトリのリストを返します。

パラメータ	説明
directory	型: PathLike | None デフォルト: None
packages	型: list[str | tuple[str, str]] | None デフォルト: None

starlette/staticfiles.pyのソースコード

def get_directories(
    self,
    directory: PathLike | None = None,
    packages: list[str | tuple[str, str]] | None = None,
) -> list[PathLike]:
    """
    Given `directory` and `packages` arguments, return a list of all the
    directories that should be used for serving static files from.
    """
    directories = []
    if directory is not None:
        directories.append(directory)

    for package in packages or []:
        if isinstance(package, tuple):
            package, statics_dir = package
        else:
            statics_dir = "statics"
        spec = importlib.util.find_spec(package)
        assert spec is not None, f"Package {package!r} could not be found."
        assert spec.origin is not None, f"Package {package!r} could not be found."
        package_directory = os.path.normpath(os.path.join(spec.origin, "..", statics_dir))
        assert os.path.isdir(
            package_directory
        ), f"Directory '{statics_dir!r}' in package {package!r} could not be found."
        directories.append(package_directory)

    return directories

get_path

get_path(scope)

WSGIスコープを指定して、OS固有のパスセパレータを使用し、「..」、「.」コンポーネントを削除した、配信するpath文字列を返します。

パラメータ	説明
scope	型: Scope

starlette/staticfiles.pyのソースコード

def get_path(self, scope: Scope) -> str:
    """
    Given the ASGI scope, return the `path` string to serve up,
    with OS specific path separators, and any '..', '.' components removed.
    """
    route_path = get_route_path(scope)
    return os.path.normpath(os.path.join(*route_path.split("/")))

get_response async

get_response(path, scope)

着信パス、メソッド、リクエストヘッダーを指定して、HTTPレスポンスを返します。

パラメータ	説明
path	型: str
scope	型: Scope

starlette/staticfiles.pyのソースコード

async def get_response(self, path: str, scope: Scope) -> Response:
    """
    Returns an HTTP response, given the incoming path, method and request headers.
    """
    if scope["method"] not in ("GET", "HEAD"):
        raise HTTPException(status_code=405)

    try:
        full_path, stat_result = await anyio.to_thread.run_sync(self.lookup_path, path)
    except PermissionError:
        raise HTTPException(status_code=401)
    except OSError as exc:
        # Filename is too long, so it can't be a valid static file.
        if exc.errno == errno.ENAMETOOLONG:
            raise HTTPException(status_code=404)

        raise exc

    if stat_result and stat.S_ISREG(stat_result.st_mode):
        # We have a static file to serve.
        return self.file_response(full_path, stat_result, scope)

    elif stat_result and stat.S_ISDIR(stat_result.st_mode) and self.html:
        # We're in HTML mode, and have got a directory URL.
        # Check if we have 'index.html' file to serve.
        index_path = os.path.join(path, "index.html")
        full_path, stat_result = await anyio.to_thread.run_sync(self.lookup_path, index_path)
        if stat_result is not None and stat.S_ISREG(stat_result.st_mode):
            if not scope["path"].endswith("/"):
                # Directory URLs should redirect to always end in "/".
                url = URL(scope=scope)
                url = url.replace(path=url.path + "/")
                return RedirectResponse(url=url)
            return self.file_response(full_path, stat_result, scope)

    if self.html:
        # Check for '404.html' if we're in HTML mode.
        full_path, stat_result = await anyio.to_thread.run_sync(self.lookup_path, "404.html")
        if stat_result and stat.S_ISREG(stat_result.st_mode):
            return FileResponse(full_path, stat_result=stat_result, status_code=404)
    raise HTTPException(status_code=404)

lookup_path

lookup_path(path)

パラメータ	説明
path	型: str

starlette/staticfiles.pyのソースコード

def lookup_path(self, path: str) -> tuple[str, os.stat_result | None]:
    for directory in self.all_directories:
        joined_path = os.path.join(directory, path)
        if self.follow_symlink:
            full_path = os.path.abspath(joined_path)
        else:
            full_path = os.path.realpath(joined_path)
        directory = os.path.realpath(directory)
        if os.path.commonpath([full_path, directory]) != directory:
            # Don't allow misbehaving clients to break out of the static files
            # directory.
            continue
        try:
            return full_path, os.stat(full_path)
        except (FileNotFoundError, NotADirectoryError):
            continue
    return "", None

file_response

file_response(
    full_path, stat_result, scope, status_code=200
)

パラメータ	説明
full_path	型: PathLike
stat_result	型: stat_result
scope	型: Scope
status_code	型: int デフォルト: 200

starlette/staticfiles.pyのソースコード

def file_response(
    self,
    full_path: PathLike,
    stat_result: os.stat_result,
    scope: Scope,
    status_code: int = 200,
) -> Response:
    request_headers = Headers(scope=scope)

    response = FileResponse(full_path, status_code=status_code, stat_result=stat_result)
    if self.is_not_modified(response.headers, request_headers):
        return NotModifiedResponse(response.headers)
    return response

check_config async

check_config()

StaticFilesが実際にディレクトリを指しているかどうかを一度限りの構成チェックを実行して、404レスポンスを返すだけでなく、明瞭なエラーを発生させることができます。

starlette/staticfiles.pyのソースコード

async def check_config(self) -> None:
    """
    Perform a one-off configuration check that StaticFiles is actually
    pointed at a directory, so that we can raise loud errors rather than
    just returning 404 responses.
    """
    if self.directory is None:
        return

    try:
        stat_result = await anyio.to_thread.run_sync(os.stat, self.directory)
    except FileNotFoundError:
        raise RuntimeError(f"StaticFiles directory '{self.directory}' does not exist.")
    if not (stat.S_ISDIR(stat_result.st_mode) or stat.S_ISLNK(stat_result.st_mode)):
        raise RuntimeError(f"StaticFiles path '{self.directory}' is not a directory.")

is_not_modified

is_not_modified(response_headers, request_headers)

リクエストヘッダーとレスポンスヘッダーを指定して、HTTP「変更なし」レスポンスを代わりに返すことができる場合にTrueを返します。

パラメータ	説明
response_headers	型: Headers
request_headers	型: Headers

starlette/staticfiles.pyのソースコード

def is_not_modified(self, response_headers: Headers, request_headers: Headers) -> bool:
    """
    Given the request and response headers, return `True` if an HTTP
    "Not Modified" response could be returned instead.
    """
    try:
        if_none_match = request_headers["if-none-match"]
        etag = response_headers["etag"]
        if etag in [tag.strip(" W/") for tag in if_none_match.split(",")]:
            return True
    except KeyError:
        pass

    try:
        if_modified_since = parsedate(request_headers["if-modified-since"])
        last_modified = parsedate(response_headers["last-modified"])
        if if_modified_since is not None and last_modified is not None and if_modified_since >= last_modified:
            return True
    except KeyError:
        pass

    return False