flet-web 1.1.0.dev1__tar.gz → 1.1.0.dev3__tar.gz

{flet_web-1.1.0.dev1 → flet_web-1.1.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flet-web
-Version: 1.1.0.dev1
+Version: 1.1.0.dev3
 Summary: Flet web client in Flutter.
 Author-email: "Appveyor Systems Inc." <hello@flet.dev>
 License-Expression: Apache-2.0
@@ -9,7 +9,7 @@ Project-URL: Repository, https://github.com/flet-dev/flet
 Project-URL: Documentation, https://flet.dev/docs
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: flet==1.1.0.dev1
+Requires-Dist: flet==1.1.0.dev3
 Requires-Dist: fastapi>=0.115.12
 Requires-Dist: websockets>=13.0
 Requires-Dist: uvicorn>=0.35.0

{flet_web-1.1.0.dev1 → flet_web-1.1.0.dev3}/pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "flet-web"
-version = "1.1.0.dev1"
+version = "1.1.0.dev3"
 description = "Flet web client in Flutter."
 authors = [{ name = "Appveyor Systems Inc.", email = "hello@flet.dev" }]
 license = "Apache-2.0"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
-    "flet==1.1.0.dev1",
+    "flet==1.1.0.dev3",
     "fastapi >=0.115.12",
     "websockets >=13.0",
     "uvicorn >=0.35.0",

flet_web-1.1.0.dev3/src/flet_web/compression.py

@@ -0,0 +1,101 @@
+import gzip
+import os
+import shutil
+
+COMPRESSIBLE_EXTENSIONS = {
+    ".css",
+    ".html",
+    ".js",
+    ".json",
+    ".map",
+    ".mjs",
+    ".otf",
+    ".svg",
+    ".ttf",
+    ".txt",
+    ".wasm",
+    ".xml",
+}
+"""
+Extensions of files sent gzip-compressed to browsers that accept it.
+
+Text and WebAssembly files shrink about 3x with gzip; images, archives and
+`.woff2` fonts are already compressed.
+"""
+
+MIN_COMPRESSED_FILE_SIZE = 1024
+"""
+Size in bytes below which files are sent uncompressed, as compression saves less
+than it costs.
+"""
+
+
+def is_compressible(path: str, stat_result: os.stat_result) -> bool:
+    """
+    Whether a static file is served gzip-compressed to browsers that accept it.
+
+    Args:
+        path: Path of the file.
+        stat_result: The file's `os.stat()` result.
+    """
+
+    return (
+        os.path.splitext(path)[1].lower() in COMPRESSIBLE_EXTENSIONS
+        and stat_result.st_size >= MIN_COMPRESSED_FILE_SIZE
+    )
+
+
+def accepts_gzip(accept_encoding: str) -> bool:
+    """
+    Whether an `Accept-Encoding` request header allows a gzip response.
+
+    Args:
+        accept_encoding: Value of the header, e.g. `"gzip, deflate, br"`.
+
+    Returns:
+        `True` if `gzip`, or else `*`, is listed without `q=0`.
+    """
+
+    qualities = {}
+    for coding in accept_encoding.split(","):
+        name, *params = coding.split(";")
+        quality = 1.0
+        for param in params:
+            key, _, value = param.partition("=")
+            if key.strip().lower() == "q":
+                try:
+                    quality = float(value)
+                except ValueError:
+                    quality = 0.0
+        qualities[name.strip().lower()] = quality
+    return qualities.get("gzip", qualities.get("*", 0.0)) > 0
+
+
+def write_gzip(source: str, target: str, stat_result: os.stat_result):
+    """
+    Write a gzip-compressed copy of a file.
+
+    The copy gets the source's modification time, so that it is served with the
+    same `Last-Modified` header. A copy left unfinished by an error is removed.
+
+    Args:
+        source: Path of the file to compress.
+        target: Path of the compressed copy.
+        stat_result: The source's `os.stat()` result.
+    """
+
+    temp = f"{target}.tmp"
+    try:
+        with (
+            open(source, "rb") as src,
+            open(temp, "wb") as raw,
+            gzip.GzipFile(
+                filename="", mode="wb", compresslevel=6, fileobj=raw, mtime=0
+            ) as dst,
+        ):
+            shutil.copyfileobj(src, dst)
+        os.utime(temp, ns=(stat_result.st_atime_ns, stat_result.st_mtime_ns))
+        os.replace(temp, target)
+    finally:
+        if os.path.exists(temp):
+            os.remove(temp)

{flet_web-1.1.0.dev1 → flet_web-1.1.0.dev3}/src/flet_web/fastapi/flet_static_files.py

@@ -1,12 +1,19 @@
+import hashlib
 import logging
 import mimetypes
 import os
 import shutil
 import tempfile
+from email.utils import parsedate
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Union
 
+import anyio
+import anyio.to_thread
 from fastapi.staticfiles import StaticFiles
+from starlette.datastructures import Headers
+from starlette.responses import FileResponse, Response
+from starlette.staticfiles import NotModifiedResponse
 from starlette.types import Receive, Scope, Send
 
 import flet_web.fastapi as flet_fastapi
@@ -18,6 +25,7 @@ from flet_web import (
     patch_index_html,
     patch_manifest_json,
 )
+from flet_web.compression import accepts_gzip, is_compressible, write_gzip
 from flet_web.fastapi.flet_app_manager import app_manager
 
 logger = logging.getLogger(flet_fastapi.__name__)
@@ -63,6 +71,13 @@ class FletStaticFiles(StaticFiles):
     """
     Serve Flet app static files.
 
+    Text and WebAssembly files, like the web client's `main.dart.wasm` and
+    `main.dart.js`, are sent gzip-compressed to browsers that accept it, which
+    makes them about 3x smaller to download. Each file is compressed once, in a
+    worker thread, on its first request, and the compressed copy is kept in a
+    temporary directory until the server exits. Byte range requests get the
+    uncompressed file.
+
     Args:
         assets_dir: Path to app's assets directory. A relative path is resolved
             against the current working directory.
@@ -104,6 +119,9 @@ class FletStaticFiles(StaticFiles):
         self.__no_cdn = no_cdn
         self.__websocket_endpoint_path = websocket_endpoint_path
         self.__once = Once()
+        self.__gzip_dir: Optional[str] = None
+        self.__gzip_locks: dict[str, anyio.Lock] = {}
+        self.__gzip_failures: set[str] = set()
 
         env_web_renderer = os.getenv("FLET_WEB_RENDERER")
         if env_web_renderer:
@@ -133,6 +151,167 @@ class FletStaticFiles(StaticFiles):
         await self.__once.do(self.__config, scope["root_path"])
         await super().__call__(scope, receive, send)
 
+    def file_response(
+        self,
+        full_path: Union[str, os.PathLike[str]],
+        stat_result: os.stat_result,
+        scope: Scope,
+        status_code: int = 200,
+    ) -> Response:
+        """
+        Respond with a static file, adding `Vary: Accept-Encoding` to
+        compressible ones.
+
+        Unlike `StaticFiles`, this never responds with `304 Not Modified`:
+        `get_response()` checks the browser's cached copy once it has picked
+        the plain or compressed file.
+        """
+        response = FileResponse(
+            full_path, status_code=status_code, stat_result=stat_result
+        )
+        if is_compressible(str(full_path), stat_result):
+            # Tells caches that the response depends on the browser's
+            # `Accept-Encoding`, so they keep the plain and gzip versions apart.
+            response.headers["Vary"] = "Accept-Encoding"
+        return response
+
+    async def get_response(self, path: str, scope: Scope) -> Response:
+        """
+        Respond with a static file, gzip-compressed if the browser accepts it.
+
+        Args:
+            path: Requested path, relative to the mounted static root.
+            scope: ASGI request scope.
+
+        Returns:
+            The compressed file for a `200` response of a compressible file to a
+                request that accepts gzip and has no `Range` header; otherwise
+                the response of `StaticFiles`. Either is `304 Not Modified` if
+                the browser has that same file cached.
+        """
+
+        response = await super().get_response(path, scope)
+        if response.status_code != 200 or not isinstance(response, FileResponse):
+            return response
+
+        request_headers = Headers(scope=scope)
+        if (
+            response.stat_result is not None
+            and is_compressible(str(response.path), response.stat_result)
+            and "range" not in request_headers
+            and accepts_gzip(request_headers.get("accept-encoding", ""))
+        ):
+            # Derived from the plain file's `ETag`, so it changes whenever the
+            # file does, and never equals it.
+            etag = response.headers["etag"].removesuffix('"') + '-gzip"'
+            gzip_headers = Headers(
+                {
+                    "etag": etag,
+                    "last-modified": response.headers["last-modified"],
+                    "vary": "Accept-Encoding",
+                }
+            )
+            # Checked before compressing, so a browser revalidating its copy
+            # after a server restart doesn't wait for the file to be compressed.
+            if self.is_not_modified(gzip_headers, request_headers):
+                return NotModifiedResponse(gzip_headers)
+
+            compressed = await self.__compress(str(response.path), response.stat_result)
+            if compressed:
+                gzip_path, gzip_stat = compressed
+                response = FileResponse(
+                    gzip_path,
+                    stat_result=gzip_stat,
+                    media_type=response.media_type,
+                    headers={
+                        "Content-Encoding": "gzip",
+                        "ETag": etag,
+                        "Vary": "Accept-Encoding",
+                    },
+                )
+
+        if self.is_not_modified(response.headers, request_headers):
+            return NotModifiedResponse(response.headers)
+        return response
+
+    def is_not_modified(
+        self, response_headers: Headers, request_headers: Headers
+    ) -> bool:
+        """
+        Whether the browser's cached copy of a file is still current.
+
+        `If-None-Match`, when sent, decides alone, so a cached copy in the
+        other encoding, which has the same `Last-Modified`, is never taken as
+        current.
+
+        Args:
+            response_headers: Headers of the response that would be sent.
+            request_headers: Headers of the request.
+        """
+
+        if if_none_match := request_headers.get("if-none-match"):
+            tags = [tag.strip().removeprefix("W/") for tag in if_none_match.split(",")]
+            return response_headers["etag"] in tags or "*" in tags
+
+        if_modified_since = parsedate(request_headers.get("if-modified-since", ""))
+        last_modified = parsedate(response_headers.get("last-modified", ""))
+        return (
+            if_modified_since is not None
+            and last_modified is not None
+            and if_modified_since >= last_modified
+        )
+
+    async def __compress(
+        self, path: str, stat_result: os.stat_result
+    ) -> Optional[tuple[str, os.stat_result]]:
+        """
+        Get the gzip-compressed copy of a file, compressing it first if needed.
+
+        Copies are keyed by the file's identity on disk, size and modification
+        time: a file changed while the server runs is compressed again, and
+        paths that name the same file, such as differently cased ones on a
+        case-insensitive file system, share one copy. Concurrent requests for
+        the same file wait for one compression. A file that fails to compress
+        is logged and not tried again until it changes.
+
+        Args:
+            path: Path of the file.
+            stat_result: The file's `os.stat()` result.
+
+        Returns:
+            The path and `os.stat()` result of the compressed copy, or `None` if
+                the file could not be compressed.
+        """
+
+        assert self.__gzip_dir
+        identity = (
+            f"{stat_result.st_dev}:{stat_result.st_ino}"
+            if stat_result.st_ino
+            else os.path.normcase(os.path.realpath(path))
+        )
+        key = hashlib.sha256(
+            f"{identity}\0{stat_result.st_size}\0{stat_result.st_mtime_ns}".encode()
+        ).hexdigest()
+        if key in self.__gzip_failures:
+            return None
+        gzip_path = os.path.join(self.__gzip_dir, f"{key}.gz")
+
+        def compress() -> os.stat_result:
+            if not os.path.exists(gzip_path):
+                write_gzip(path, gzip_path, stat_result)
+            return os.stat(gzip_path)
+
+        lock = self.__gzip_locks.setdefault(key, anyio.Lock())
+        async with lock:
+            if key in self.__gzip_failures:
+                return None
+            try:
+                return gzip_path, await anyio.to_thread.run_sync(compress)
+            except OSError as e:
+                logger.warning(f"Could not compress {path}: {e}")
+                self.__gzip_failures.add(key)
+                return None
+
     def lookup_path(self, path: str) -> tuple[str, Optional[os.stat_result]]:
         """Resolve a static file path, with SPA fallback for client-side routes.
 
@@ -195,6 +374,11 @@ class FletStaticFiles(StaticFiles):
         app_manager.add_temp_dir(temp_dir)
         logger.info(f"Temp dir created for patched index and manifest: {temp_dir}")
 
+        # where gzip-compressed copies of served files are stored; outside
+        # temp_dir, which is served
+        self.__gzip_dir = tempfile.mkdtemp()
+        app_manager.add_temp_dir(self.__gzip_dir)
+
         # "standard" web files
         web_dir = get_package_web_dir()
         if os.getenv("FLET_WEB_PATH"):

flet_web-1.1.0.dev3/src/flet_web/version.py

@@ -0,0 +1 @@
+version = "1.1.0.dev3"

{flet_web-1.1.0.dev1 → flet_web-1.1.0.dev3}/src/flet_web.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flet-web
-Version: 1.1.0.dev1
+Version: 1.1.0.dev3
 Summary: Flet web client in Flutter.
 Author-email: "Appveyor Systems Inc." <hello@flet.dev>
 License-Expression: Apache-2.0
@@ -9,7 +9,7 @@ Project-URL: Repository, https://github.com/flet-dev/flet
 Project-URL: Documentation, https://flet.dev/docs
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: flet==1.1.0.dev1
+Requires-Dist: flet==1.1.0.dev3
 Requires-Dist: fastapi>=0.115.12
 Requires-Dist: websockets>=13.0
 Requires-Dist: uvicorn>=0.35.0

{flet_web-1.1.0.dev1 → flet_web-1.1.0.dev3}/src/flet_web.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 README.md
 pyproject.toml
 src/flet_web/__init__.py
+src/flet_web/compression.py
 src/flet_web/patch_index.py
 src/flet_web/uploads.py
 src/flet_web/version.py
@@ -21,4 +22,5 @@ src/flet_web/fastapi/oauth_state.py
 src/flet_web/fastapi/serve_fastapi_web_app.py
 tests/test_fastapi.py
 tests/test_loading_logo.py
-tests/test_patch_index.py
+tests/test_patch_index.py
+tests/test_static_compression.py

{flet_web-1.1.0.dev1 → flet_web-1.1.0.dev3}/src/flet_web.egg-info/requires.txt

@@ -1,4 +1,4 @@
-flet==1.1.0.dev1
+flet==1.1.0.dev3
 fastapi>=0.115.12
 websockets>=13.0
 uvicorn>=0.35.0

flet_web-1.1.0.dev3/tests/test_static_compression.py

@@ -0,0 +1,346 @@
+"""Gzip compression of the static files served for a Flet web app."""
+
+import gzip
+import importlib
+import os
+
+import anyio
+import httpx
+import pytest
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+compression = importlib.import_module("flet_web.compression")
+static_files = importlib.import_module("flet_web.fastapi.flet_static_files")
+
+GZIP = {"Accept-Encoding": "gzip"}
+WASM = bytes(range(256)) * 4096
+
+
+@pytest.fixture
+def web(tmp_path, monkeypatch):
+    """A packaged web client directory with a compressible and a binary file."""
+    web = tmp_path / "web"
+    web.mkdir()
+    (web / "index.html").write_text("<html><head></head><body></body></html>")
+    (web / "manifest.json").write_text("{}")
+    (web / "main.dart.wasm").write_bytes(WASM)
+    (web / "small.js").write_text("main();")
+    (web / "logo.png").write_bytes(b"\x89PNG" + bytes(4096))
+    monkeypatch.setattr(static_files, "get_package_web_dir", lambda: str(web))
+    return web
+
+
+@pytest.fixture
+def compressions(monkeypatch):
+    """Paths of the files compressed, in order."""
+    calls = []
+    write_gzip = static_files.write_gzip
+    monkeypatch.setattr(
+        static_files,
+        "write_gzip",
+        lambda *args: calls.append(args[0]) or write_gzip(*args),
+    )
+    return calls
+
+
+@pytest.fixture
+def client(web):
+    """A test client of an app serving `web`."""
+    app = FastAPI()
+    app.mount("/", static_files.FletStaticFiles())
+    with TestClient(app) as client:
+        yield client
+
+
+class TestAcceptsGzip:
+    @pytest.mark.parametrize(
+        ("accept_encoding", "expected"),
+        [
+            ("gzip, deflate, br, zstd", True),
+            ("GZIP", True),
+            ("br;q=1.0, gzip;q=0.5", True),
+            ("gzip;q=0", False),
+            ("gzip;q=0.0, br", False),
+            ("gzip;q=invalid", False),
+            ("br, deflate", False),
+            ("", False),
+            ("*;q=1, identity;q=0", True),
+            ("*, gzip;q=0", False),
+            ("*;q=0", False),
+        ],
+    )
+    def test_reads_accept_encoding(self, accept_encoding, expected):
+        """`gzip`, or else `*`, is accepted when listed without a zero quality."""
+        assert compression.accepts_gzip(accept_encoding) is expected
+
+
+class TestCompressedResponses:
+    def test_sends_gzip_to_browsers_that_accept_it(self, client):
+        """A compressible file is sent gzipped with its own media type."""
+        response = client.get("/main.dart.wasm", headers=GZIP)
+
+        assert response.status_code == 200
+        assert response.headers["content-encoding"] == "gzip"
+        assert response.headers["content-type"] == "application/wasm"
+        assert response.headers["vary"] == "Accept-Encoding"
+        assert int(response.headers["content-length"]) < len(WASM) / 10
+        assert response.content == WASM
+
+    def test_sends_plain_file_to_other_browsers(self, client):
+        """Without gzip in `Accept-Encoding`, the file is sent as is."""
+        response = client.get(
+            "/main.dart.wasm", headers={"Accept-Encoding": "identity"}
+        )
+
+        assert response.status_code == 200
+        assert "content-encoding" not in response.headers
+        assert response.headers["vary"] == "Accept-Encoding"
+        assert int(response.headers["content-length"]) == len(WASM)
+        assert response.content == WASM
+
+    def test_sends_plain_bytes_for_range_requests(self, client):
+        """A byte range is taken from the uncompressed file."""
+        response = client.get(
+            "/main.dart.wasm", headers={**GZIP, "Range": "bytes=256-511"}
+        )
+
+        assert response.status_code == 206
+        assert "content-encoding" not in response.headers
+        assert response.content == WASM[256:512]
+
+    def test_head_request_gets_compressed_headers(self, client):
+        """A `HEAD` request gets the compressed file's headers and no body."""
+        get = client.get("/main.dart.wasm", headers=GZIP)
+        head = client.head("/main.dart.wasm", headers=GZIP)
+
+        assert head.status_code == 200
+        assert head.headers["content-encoding"] == "gzip"
+        assert head.headers["content-length"] == get.headers["content-length"]
+        assert head.headers["etag"] == get.headers["etag"]
+        assert head.content == b""
+
+    @pytest.mark.parametrize("path", ["/small.js", "/logo.png"])
+    def test_sends_small_and_binary_files_as_is(self, client, path):
+        """Files too small or already compressed are not compressed."""
+        response = client.get(path, headers=GZIP)
+
+        assert response.status_code == 200
+        assert "content-encoding" not in response.headers
+        assert "vary" not in response.headers
+
+    def test_compresses_the_patched_index(self, web):
+        """The index served for app routes is compressed when large enough."""
+        (web / "index.html").write_text(f"<html><body>{'x' * 4096}</body></html>")
+        app = FastAPI()
+        app.mount("/", static_files.FletStaticFiles())
+        with TestClient(app) as client:
+            response = client.get("/some/route", headers=GZIP)
+
+        assert response.status_code == 200
+        assert response.headers["content-encoding"] == "gzip"
+        assert "x" * 4096 in response.text
+
+
+class TestCompressedCopies:
+    def test_compresses_each_file_once(self, client, compressions):
+        """Later requests reuse the compressed copy."""
+        for _ in range(3):
+            assert client.get("/main.dart.wasm", headers=GZIP).content == WASM
+
+        assert len(compressions) == 1
+
+    def test_concurrent_first_requests_compress_once(self, web, compressions):
+        """Requests arriving together wait for one compression."""
+        app = FastAPI()
+        app.mount("/", static_files.FletStaticFiles())
+        contents = []
+
+        async def fetch(client):
+            response = await client.get("/main.dart.wasm", headers=GZIP)
+            contents.append(response.content)
+
+        async def main():
+            transport = httpx.ASGITransport(app=app)
+            async with (
+                httpx.AsyncClient(
+                    transport=transport, base_url="http://test"
+                ) as client,
+                anyio.create_task_group() as tg,
+            ):
+                for _ in range(5):
+                    tg.start_soon(fetch, client)
+
+        anyio.run(main)
+
+        assert contents == [WASM] * 5
+        assert len(compressions) == 1
+
+    def test_compresses_a_changed_file_again(self, client, web):
+        """A file changed while the server runs is served with its new content."""
+        assert client.get("/main.dart.wasm", headers=GZIP).content == WASM
+
+        changed = WASM[::-1]
+        path = web / "main.dart.wasm"
+        path.write_bytes(changed)
+        stat = path.stat()
+        os.utime(path, ns=(stat.st_atime_ns, stat.st_mtime_ns + 1_000_000_000))
+
+        assert client.get("/main.dart.wasm", headers=GZIP).content == changed
+
+    def test_paths_naming_the_same_file_share_one_copy(self, client, web, compressions):
+        """Differently cased paths to one file are compressed once."""
+        if not (web / "MAIN.DART.WASM").exists():
+            pytest.skip("The file system is case-sensitive")
+
+        for path in ["/main.dart.wasm", "/MAIN.dart.wasm", "/Main.Dart.Wasm"]:
+            assert client.get(path, headers=GZIP).content == WASM
+
+        assert len(compressions) == 1
+
+    def test_compressed_copy_is_reproducible(self, web, tmp_path):
+        """Compressing a file twice gives the same bytes and modification time."""
+        source = web / "main.dart.wasm"
+        stat = source.stat()
+        first, second = tmp_path / "first.gz", tmp_path / "second.gz"
+        compression.write_gzip(str(source), str(first), stat)
+        compression.write_gzip(str(source), str(second), stat)
+
+        assert first.read_bytes() == second.read_bytes()
+        assert gzip.decompress(first.read_bytes()) == WASM
+        assert first.stat().st_mtime_ns == stat.st_mtime_ns
+
+    def test_unfinished_copy_is_removed(self, web, tmp_path, monkeypatch):
+        """A copy that fails partway through writing leaves no file behind."""
+
+        def fail(src, dst):
+            dst.write(src.read(1024))
+            raise OSError("No space left on device")
+
+        monkeypatch.setattr(compression.shutil, "copyfileobj", fail)
+        source = web / "main.dart.wasm"
+        target = tmp_path / "copies" / "main.gz"
+        target.parent.mkdir()
+
+        with pytest.raises(OSError):
+            compression.write_gzip(str(source), str(target), source.stat())
+
+        assert list(target.parent.iterdir()) == []
+
+    def test_sends_plain_file_when_compression_fails(self, client, monkeypatch):
+        """A file that fails to compress is sent plain and not compressed again."""
+        calls = []
+
+        def fail(*args):
+            calls.append(args[0])
+            raise OSError("No space left on device")
+
+        monkeypatch.setattr(static_files, "write_gzip", fail)
+        for _ in range(3):
+            response = client.get("/main.dart.wasm", headers=GZIP)
+            assert response.status_code == 200
+            assert "content-encoding" not in response.headers
+            assert response.content == WASM
+
+        assert len(calls) == 1
+
+
+class TestRevalidation:
+    def test_compressed_and_plain_files_have_different_etags(self, client):
+        """Caches can tell the two encodings of a file apart."""
+        compressed = client.get("/main.dart.wasm", headers=GZIP)
+        plain = client.get("/main.dart.wasm", headers={"Accept-Encoding": "identity"})
+
+        assert compressed.headers["etag"] != plain.headers["etag"]
+        assert compressed.headers["last-modified"] == plain.headers["last-modified"]
+
+    def test_cached_compressed_file_is_not_modified(self, client):
+        """The `ETag` of a cached compressed file gets `304 Not Modified`."""
+        etag = client.get("/main.dart.wasm", headers=GZIP).headers["etag"]
+
+        response = client.get(
+            "/main.dart.wasm", headers={**GZIP, "If-None-Match": etag}
+        )
+
+        assert response.status_code == 304
+        assert response.headers["vary"] == "Accept-Encoding"
+
+    def test_compressed_etag_does_not_match_plain_file(self, client):
+        """A plain request with the compressed file's `ETag` gets the file."""
+        etag = client.get("/main.dart.wasm", headers=GZIP).headers["etag"]
+
+        response = client.get(
+            "/main.dart.wasm",
+            headers={"Accept-Encoding": "identity", "If-None-Match": etag},
+        )
+
+        assert response.status_code == 200
+        assert response.content == WASM
+
+    def test_cached_compressed_file_is_revalidated_by_date(self, client):
+        """`If-Modified-Since` alone gets a `304` for the compressed file."""
+        compressed = client.get("/main.dart.wasm", headers=GZIP)
+
+        response = client.get(
+            "/main.dart.wasm",
+            headers={
+                **GZIP,
+                "If-Modified-Since": compressed.headers["last-modified"],
+            },
+        )
+
+        assert response.status_code == 304
+        assert response.headers["etag"] == compressed.headers["etag"]
+
+    def test_plain_etag_does_not_match_compressed_file(self, client):
+        """A gzip request with the plain file's `ETag` gets the compressed file."""
+        plain = client.get("/main.dart.wasm", headers={"Accept-Encoding": "identity"})
+
+        response = client.get(
+            "/main.dart.wasm",
+            headers={
+                **GZIP,
+                "If-None-Match": plain.headers["etag"],
+                "If-Modified-Since": plain.headers["last-modified"],
+            },
+        )
+
+        assert response.status_code == 200
+        assert response.headers["content-encoding"] == "gzip"
+        assert response.content == WASM
+
+    def test_etag_changes_with_the_file(self, client, web):
+        """Changed content of the same modification time gets a new `ETag`."""
+        path = web / "main.dart.wasm"
+        path.write_bytes(b"A" * 1024)
+        stat = path.stat()
+        old = client.get("/main.dart.wasm", headers=GZIP)
+
+        path.write_bytes(b"A" * 1025)
+        os.utime(path, ns=(stat.st_atime_ns, stat.st_mtime_ns))
+        response = client.get(
+            "/main.dart.wasm", headers={**GZIP, "If-None-Match": old.headers["etag"]}
+        )
+
+        assert response.status_code == 200
+        assert response.headers["etag"] != old.headers["etag"]
+        assert response.content == b"A" * 1025
+
+    def test_revalidation_after_restart_does_not_compress(self, web, compressions):
+        """A cached compressed file is confirmed without compressing it again."""
+        app = FastAPI()
+        app.mount("/", static_files.FletStaticFiles())
+        with TestClient(app) as client:
+            etag = client.get("/main.dart.wasm", headers=GZIP).headers["etag"]
+
+        restarted = FastAPI()
+        restarted.mount("/", static_files.FletStaticFiles())
+        with TestClient(restarted) as client:
+            response = client.get(
+                "/main.dart.wasm", headers={**GZIP, "If-None-Match": etag}
+            )
+
+        assert response.status_code == 304
+        assert response.headers["etag"] == etag
+        assert response.headers["vary"] == "Accept-Encoding"
+        assert len(compressions) == 1

flet_web-1.1.0.dev1/src/flet_web/version.py

@@ -1 +0,0 @@
-version = "1.1.0.dev1"