asgi-compression 0.1.0__tar.gz

asgi_compression-0.1.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: asgi-compression
+Version: 0.1.0
+Summary: Add your description here
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: multidict>=6.2.0
+Provides-Extra: all
+Requires-Dist: brotli>=1.1.0; extra == "all"
+Requires-Dist: zstandard>=0.23.0; extra == "all"
+Provides-Extra: br
+Requires-Dist: brotli>=1.1.0; extra == "br"
+Provides-Extra: zstd
+Requires-Dist: zstandard>=0.23.0; extra == "zstd"

asgi_compression-0.1.0/asgi_compression/__init__.py

@@ -0,0 +1,17 @@
+from .base import CompressionAlgorithm, ContentEncoding
+from .brotli import BrotliAlgorithm, BrotliMode
+from .gzip import GzipAlgorithm
+from .identity import IdentityAlgorithm
+from .middleware import CompressionMiddleware
+from .zstd import ZstdAlgorithm
+
+__all__ = [
+    "CompressionMiddleware",
+    "CompressionAlgorithm",
+    "ContentEncoding",
+    "GzipAlgorithm",
+    "BrotliAlgorithm",
+    "BrotliMode",
+    "IdentityAlgorithm",
+    "ZstdAlgorithm",
+]

asgi_compression-0.1.0/asgi_compression/base.py

@@ -0,0 +1,140 @@
+import typing
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from enum import Enum
+
+from .types import ASGIApp, Headers, Message, Receive, Scope, Send
+
+DEFAULT_EXCLUDED_CONTENT_TYPES = ("text/event-stream",)
+DEFAULT_MINIMUM_SIZE = 500
+
+
+class ContentEncoding(str, Enum):
+    GZIP = "gzip"
+    BROTLI = "br"
+    ZSTD = "zstd"
+    IDENTITY = "identity"
+
+
+async def unattached_send(message: Message) -> typing.NoReturn:
+    raise RuntimeError("send awaitable not set")  # pragma: no cover
+
+
+class CompressionResponder(ABC):
+    """Base class for all compression responders."""
+
+    content_encoding: ContentEncoding
+
+    def __init__(self, app: ASGIApp, minimum_size: int) -> None:
+        self.app = app
+        self.minimum_size = minimum_size
+        self._send: Send = unattached_send
+        self._initial_message: Message = {}
+        self._started = False
+        self._content_encoding_set = False
+        self._content_type_is_excluded = False
+
+    async def __call__(
+        self,
+        scope: Scope,
+        receive: Receive,
+        send: Send,
+    ) -> None:
+        self._send = send
+        await self.app(scope, receive, self.send_with_compression)
+
+    async def send_with_compression(self, message: Message) -> None:
+        message_type = message["type"]
+        if message_type == "http.response.start":
+            # Don't send the initial message until we've determined how to
+            # modify the outgoing headers correctly.
+            self._initial_message = message
+            headers = Headers(raw=self._initial_message["headers"])
+
+            self._content_encoding_set = "content-encoding" in headers
+            self._content_type_is_excluded = headers.get(
+                "content-type", ""
+            ).startswith(DEFAULT_EXCLUDED_CONTENT_TYPES)
+
+        elif message_type == "http.response.body" and (
+            self._content_encoding_set or self._content_type_is_excluded
+        ):
+            if not self._started:
+                self._started = True
+                await self._send(self._initial_message)
+            await self._send(message)
+
+        elif message_type == "http.response.body" and not self._started:
+            self._started = True
+            body = message.get("body", b"")
+            more_body = message.get("more_body", False)
+
+            if len(body) < self.minimum_size and not more_body:
+                # Don't apply compression to small outgoing responses.
+                # Don't add Vary header for small responses
+                await self._send(self._initial_message)
+                await self._send(message)
+            elif not more_body:
+                # Standard response.
+                body = self.apply_compression(body, more_body=False)
+
+                headers = Headers(raw=self._initial_message["headers"])
+                headers.add_vary_header("Accept-Encoding")
+
+                if body != message["body"]:
+                    headers["Content-Encoding"] = self.content_encoding
+                    headers["Content-Length"] = str(len(body))
+                    message["body"] = body
+
+                self._initial_message["headers"] = headers.encode()
+                await self._send(self._initial_message)
+                await self._send(message)
+            else:
+                # Initial body in streaming response.
+                body = self.apply_compression(body, more_body=True)
+
+                headers = Headers(raw=self._initial_message["headers"])
+                headers.add_vary_header("Accept-Encoding")
+
+                if body != message["body"]:
+                    headers["Content-Encoding"] = self.content_encoding
+                    if "Content-Length" in headers:
+                        del headers["Content-Length"]
+
+                    message["body"] = body
+
+                self._initial_message["headers"] = headers.encode()
+                await self._send(self._initial_message)
+                await self._send(message)
+        elif message_type == "http.response.body":  # pragma: no branch
+            # Remaining body in streaming response.
+            body = message.get("body", b"")
+            more_body = message.get("more_body", False)
+
+            message["body"] = self.apply_compression(body, more_body=more_body)
+            await self._send(message)
+
+    @abstractmethod
+    def apply_compression(self, body: bytes, *, more_body: bool) -> bytes:
+        """Apply compression on the response body.
+
+        If more_body is False, any compression file should be closed. If it
+        isn't, it won't be closed automatically until all background tasks
+        complete.
+        """
+        raise NotImplementedError
+
+
+@dataclass
+class CompressionAlgorithm(ABC):
+    """Base class for compression algorithms."""
+
+    type: ContentEncoding
+    minimum_size: int = DEFAULT_MINIMUM_SIZE
+
+    def create_responder(self, app: ASGIApp) -> "CompressionResponder":
+        """Create a responder for this compression algorithm."""
+        raise NotImplementedError
+
+    def check_available(self) -> None:
+        """Check if the algorithm is available in the current environment."""

asgi_compression-0.1.0/asgi_compression/brotli.py

@@ -0,0 +1,101 @@
+import io
+from dataclasses import dataclass
+from enum import Enum
+from typing import TYPE_CHECKING
+
+from .base import CompressionAlgorithm, CompressionResponder, ContentEncoding
+from .types import ASGIApp
+
+if TYPE_CHECKING:
+    import brotli
+
+
+def import_brotli() -> None:
+    global brotli
+    try:
+        import brotli
+    except ImportError as e:
+        raise ImportError(
+            "brotli is not installed, run `pip install brotli`]"
+        ) from e
+
+
+class BrotliMode(Enum):
+    TEXT = "text"
+    FONT = "font"
+    GENERIC = "generic"
+
+    def to_brotli_mode(self) -> int:
+        if self == BrotliMode.TEXT:
+            return brotli.MODE_TEXT
+        elif self == BrotliMode.FONT:
+            return brotli.MODE_FONT
+        elif self == BrotliMode.GENERIC:
+            return brotli.MODE_GENERIC
+        else:
+            assert False, f"Expected code to be unreachable, but got: {self}"
+
+
+class BrotliResponder(CompressionResponder):
+    """Responder that applies brotli compression."""
+
+    content_encoding = ContentEncoding.BROTLI
+
+    def __init__(
+        self,
+        app: ASGIApp,
+        minimum_size: int,
+        quality: int = 4,
+        mode: BrotliMode = BrotliMode.TEXT,
+        lgwin: int = 22,
+        lgblock: int = 0,
+    ) -> None:
+        super().__init__(app, minimum_size)
+
+        import_brotli()
+
+        self.brotli_buffer = io.BytesIO()
+        self.compressor = brotli.Compressor(
+            quality=quality,
+            mode=mode.to_brotli_mode(),
+            lgwin=lgwin,
+            lgblock=lgblock,
+        )
+
+    def apply_compression(self, body: bytes, *, more_body: bool) -> bytes:
+        compressed = self.compressor.process(body)
+        self.brotli_buffer.write(compressed)
+
+        if not more_body:
+            final_data = self.compressor.finish()
+            self.brotli_buffer.write(final_data)
+
+        compressed_data = self.brotli_buffer.getvalue()
+
+        self.brotli_buffer.seek(0)
+        self.brotli_buffer.truncate()
+        return compressed_data
+
+
+@dataclass
+class BrotliAlgorithm(CompressionAlgorithm):
+    """Brotli compression algorithm."""
+
+    type: ContentEncoding = ContentEncoding.BROTLI
+    quality: int = 4
+    mode: BrotliMode = BrotliMode.TEXT
+    lgwin: int = 22
+    lgblock: int = 0
+
+    def create_responder(self, app: ASGIApp) -> "BrotliResponder":
+        return BrotliResponder(
+            app=app,
+            minimum_size=self.minimum_size,
+            quality=self.quality,
+            mode=self.mode,
+            lgwin=self.lgwin,
+            lgblock=self.lgblock,
+        )
+
+    def check_available(self) -> None:
+        import_brotli()

asgi_compression-0.1.0/asgi_compression/gzip.py

@@ -0,0 +1,61 @@
+import gzip
+import io
+from dataclasses import dataclass
+
+from .base import CompressionAlgorithm, CompressionResponder, ContentEncoding
+from .types import ASGIApp, Receive, Scope, Send
+
+
+class GzipResponder(CompressionResponder):
+    """Responder that applies gzip compression."""
+
+    content_encoding = ContentEncoding.GZIP
+
+    def __init__(
+        self,
+        app: ASGIApp,
+        minimum_size: int,
+        compresslevel: int = 9,
+    ) -> None:
+        super().__init__(app, minimum_size)
+
+        self.gzip_buffer = io.BytesIO()
+        self.gzip_file = gzip.GzipFile(
+            mode="wb",
+            fileobj=self.gzip_buffer,
+            compresslevel=compresslevel,
+        )
+
+    async def __call__(
+        self,
+        scope: Scope,
+        receive: Receive,
+        send: Send,
+    ) -> None:
+        with self.gzip_buffer, self.gzip_file:
+            await super().__call__(scope, receive, send)
+
+    def apply_compression(self, body: bytes, *, more_body: bool) -> bytes:
+        self.gzip_file.write(body)
+        if not more_body:
+            self.gzip_file.close()
+
+        body = self.gzip_buffer.getvalue()
+        self.gzip_buffer.seek(0)
+        self.gzip_buffer.truncate()
+        return body
+
+
+@dataclass
+class GzipAlgorithm(CompressionAlgorithm):
+    """Gzip compression algorithm."""
+
+    type: ContentEncoding = ContentEncoding.GZIP
+    compresslevel: int = 9
+
+    def create_responder(self, app: ASGIApp) -> GzipResponder:
+        return GzipResponder(
+            app=app,
+            minimum_size=self.minimum_size,
+            compresslevel=self.compresslevel,
+        )

asgi_compression-0.1.0/asgi_compression/identity.py

@@ -0,0 +1,23 @@
+from dataclasses import dataclass
+
+from .base import CompressionAlgorithm, CompressionResponder, ContentEncoding
+from .types import ASGIApp
+
+
+class IdentityResponder(CompressionResponder):
+    """Responder that doesn't apply any compression."""
+
+    content_encoding = ContentEncoding.IDENTITY
+
+    def apply_compression(self, body: bytes, *, more_body: bool) -> bytes:
+        return body
+
+
+@dataclass
+class IdentityAlgorithm(CompressionAlgorithm):
+    """No compression, identity algorithm."""
+
+    type: ContentEncoding = ContentEncoding.IDENTITY
+
+    def create_responder(self, app: ASGIApp) -> IdentityResponder:
+        return IdentityResponder(app=app, minimum_size=self.minimum_size)

asgi_compression-0.1.0/asgi_compression/middleware.py

@@ -0,0 +1,82 @@
+from typing import List, Optional, Union
+
+from .base import (
+    DEFAULT_MINIMUM_SIZE,
+    CompressionAlgorithm,
+    CompressionResponder,
+)
+from .identity import IdentityAlgorithm
+from .types import ASGIApp, Headers, Receive, Scope, Send
+
+
+class CompressionMiddleware:
+    """
+    Unified ASGI middleware for response compression.
+
+    Supports multiple compression algorithms and automatically negotiates
+    the best available algorithm based on the client's Accept-Encoding header.
+    """
+
+    def __init__(
+        self,
+        app: ASGIApp,
+        algorithms: Optional[List[CompressionAlgorithm]] = None,
+        minimum_size: int = DEFAULT_MINIMUM_SIZE,
+    ) -> None:
+        """
+        Initialize the compression middleware.
+
+        Args:
+            app: The ASGI application.
+            algorithms: List of compression algorithms to use, in order of preference.
+                If not provided, no compression will be applied.
+            minimum_size: The minimum response size to apply compression.
+                This will be used as the default for algorithms that don't specify it.
+        """
+
+        self.app = app
+        self.minimum_size = minimum_size
+
+        self.algorithms = algorithms or []
+        for algorithm in self.algorithms:
+            try:
+                algorithm.check_available()
+            except ImportError as e:
+                raise e from e
+
+        self._default_algorithm = IdentityAlgorithm(minimum_size=minimum_size)
+
+        # Set minimum_size if not explicitly set in the algorithm
+        for algorithm in self.algorithms:
+            if (
+                algorithm.minimum_size == DEFAULT_MINIMUM_SIZE
+                and minimum_size != DEFAULT_MINIMUM_SIZE
+            ):
+                algorithm.minimum_size = minimum_size
+
+    async def __call__(
+        self,
+        scope: Scope,
+        receive: Receive,
+        send: Send,
+    ) -> None:
+        """ASGI application interface."""
+        if scope["type"] != "http":  # pragma: no cover
+            await self.app(scope, receive, send)
+            return
+
+        headers = Headers(scope=scope)
+        accept_encoding = headers.get("Accept-Encoding", "")
+
+        # Find the first supported algorithm that matches the Accept-Encoding header
+        responder: Union[CompressionResponder, None] = None
+        for algorithm in self.algorithms:
+            if str(algorithm.type.value) in accept_encoding:
+                responder = algorithm.create_responder(self.app)
+                break
+
+        # If no matching algorithm, use identity (no compression)
+        if responder is None:
+            responder = self._default_algorithm.create_responder(self.app)
+
+        await responder(scope, receive, send)

asgi_compression-0.1.0/asgi_compression/types.py

@@ -0,0 +1,63 @@
+from typing import (
+    Any,
+    Awaitable,
+    Callable,
+    List,
+    Mapping,
+    MutableMapping,
+    Optional,
+)
+
+from multidict import CIMultiDict
+
+Scope = MutableMapping[str, Any]
+Message = MutableMapping[str, Any]
+Receive = Callable[[], Awaitable[Message]]
+Send = Callable[[Message], Awaitable[None]]
+ASGIApp = Callable[[Scope, Receive, Send], Awaitable[None]]
+
+
+class Headers(CIMultiDict[str]):
+    def __init__(
+        self,
+        headers: Optional[Mapping[str, str]] = None,
+        raw: Optional[list[tuple[bytes, bytes]]] = None,
+        scope: Optional[Scope] = None,
+    ) -> None:
+        headers_list: List[tuple[str, str]] = []
+        if headers is not None:
+            assert raw is None, 'Cannot set both "headers" and "raw".'
+            assert scope is None, 'Cannot set both "headers" and "scope".'
+            headers_list = list(headers.items())
+        elif raw is not None:
+            assert scope is None, 'Cannot set both "raw" and "scope".'
+            headers_list = [
+                (key.decode("latin-1"), value.decode("latin-1"))
+                for key, value in raw
+            ]
+        elif scope is not None:
+            # scope["headers"] isn't necessarily a list
+            # it might be a tuple or other iterable
+            scope_headers = scope["headers"] = list(scope["headers"])
+            headers_list = [
+                (key.decode("latin-1"), value.decode("latin-1"))
+                for key, value in scope_headers
+            ]
+
+        super().__init__(headers_list)
+
+    def add_vary_header(self, vary: str) -> None:
+        existing = self.get("vary")
+        if existing is not None:
+            # Check if the value is already in the Vary header to avoid duplication
+            values = [x.strip() for x in existing.split(",")]
+            if vary not in values:
+                vary = f"{existing}, {vary}"
+
+        self["vary"] = vary
+
+    def encode(self) -> list[tuple[bytes, bytes]]:
+        return [
+            (key.encode("latin-1"), value.encode("latin-1"))
+            for key, value in self.items()
+        ]

asgi_compression-0.1.0/asgi_compression/zstd.py

@@ -0,0 +1,92 @@
+import io
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from .base import CompressionAlgorithm, CompressionResponder, ContentEncoding
+from .types import ASGIApp, Receive, Scope, Send
+
+if TYPE_CHECKING:
+    import zstandard
+
+
+def import_zstandard() -> None:
+    global zstandard
+    try:
+        import zstandard
+    except ImportError as e:
+        raise ImportError(
+            "zstandard is not installed, run `pip install zstandard`]"
+        ) from e
+
+
+class ZstdResponder(CompressionResponder):
+    """Responder that applies Zstandard compression."""
+
+    content_encoding = ContentEncoding.ZSTD
+
+    def __init__(
+        self,
+        app: ASGIApp,
+        minimum_size: int,
+        level: int = 3,
+        threads: int = 0,
+        write_checksum: bool = False,
+        write_content_size: bool = True,
+    ) -> None:
+        super().__init__(app, minimum_size)
+
+        import_zstandard()
+
+        self.zstd_buffer = io.BytesIO()
+        self.compressor = zstandard.ZstdCompressor(
+            level=level,
+            threads=threads,
+            write_checksum=write_checksum,
+            write_content_size=write_content_size,
+        )
+        self.compression_stream = self.compressor.stream_writer(
+            self.zstd_buffer
+        )
+
+    async def __call__(
+        self,
+        scope: Scope,
+        receive: Receive,
+        send: Send,
+    ) -> None:
+        with self.zstd_buffer, self.compression_stream:
+            await super().__call__(scope, receive, send)
+
+    def apply_compression(self, body: bytes, *, more_body: bool) -> bytes:
+        self.compression_stream.write(body)
+        if not more_body:
+            self.compression_stream.flush(zstandard.FLUSH_FRAME)
+
+        body = self.zstd_buffer.getvalue()
+        self.zstd_buffer.seek(0)
+        self.zstd_buffer.truncate()
+        return body
+
+
+@dataclass
+class ZstdAlgorithm(CompressionAlgorithm):
+    """Zstandard compression algorithm."""
+
+    type: ContentEncoding = ContentEncoding.ZSTD
+    level: int = 3
+    threads: int = 0
+    write_checksum: bool = False
+    write_content_size: bool = True
+
+    def create_responder(self, app: ASGIApp) -> ZstdResponder:
+        return ZstdResponder(
+            app=app,
+            minimum_size=self.minimum_size,
+            level=self.level,
+            threads=self.threads,
+            write_checksum=self.write_checksum,
+            write_content_size=self.write_content_size,
+        )
+
+    def check_available(self) -> None:
+        import_zstandard()

asgi_compression-0.1.0/asgi_compression.egg-info/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: asgi-compression
+Version: 0.1.0
+Summary: Add your description here
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: multidict>=6.2.0
+Provides-Extra: all
+Requires-Dist: brotli>=1.1.0; extra == "all"
+Requires-Dist: zstandard>=0.23.0; extra == "all"
+Provides-Extra: br
+Requires-Dist: brotli>=1.1.0; extra == "br"
+Provides-Extra: zstd
+Requires-Dist: zstandard>=0.23.0; extra == "zstd"

asgi_compression-0.1.0/asgi_compression.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+README.md
+pyproject.toml
+asgi_compression/__init__.py
+asgi_compression/base.py
+asgi_compression/brotli.py
+asgi_compression/gzip.py
+asgi_compression/identity.py
+asgi_compression/middleware.py
+asgi_compression/types.py
+asgi_compression/zstd.py
+asgi_compression.egg-info/PKG-INFO
+asgi_compression.egg-info/SOURCES.txt
+asgi_compression.egg-info/dependency_links.txt
+asgi_compression.egg-info/requires.txt
+asgi_compression.egg-info/top_level.txt
+tests/test_middleware.py

asgi_compression-0.1.0/asgi_compression.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

asgi_compression-0.1.0/asgi_compression.egg-info/requires.txt

@@ -0,0 +1,11 @@
+multidict>=6.2.0
+
+[all]
+brotli>=1.1.0
+zstandard>=0.23.0
+
+[br]
+brotli>=1.1.0
+
+[zstd]
+zstandard>=0.23.0

asgi_compression-0.1.0/asgi_compression.egg-info/top_level.txt

@@ -0,0 +1 @@
+asgi_compression

asgi_compression-0.1.0/pyproject.toml

@@ -0,0 +1,52 @@
+[project]
+name = "asgi-compression"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = [
+    "multidict>=6.2.0",
+]
+
+[project.optional-dependencies]
+all = [
+    "brotli>=1.1.0",
+    "zstandard>=0.23.0",
+]
+br = [
+    "brotli>=1.1.0",
+]
+zstd = [
+    "zstandard>=0.23.0",
+]
+
+[dependency-groups]
+dev = [
+    "brotli>=1.1.0",
+    "django>=4.2.20",
+    "django-eventstream>=4.5.1",
+    "httpx>=0.28.1",
+    "litestar>=2.15.1",
+    "pyright>=1.1.399",
+    "pytest>=8.3.5",
+    "pytest-asyncio>=0.25.3",
+    "ruff>=0.11.6",
+    "sse-starlette>=2.2.1",
+    "starlette>=0.46.1",
+    "typing-extensions>=4.12.2",
+    "zstandard>=0.23.0",
+]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "session"
+
+[tool.ruff]
+line-length = 80
+
+[tool.ruff.lint.isort]
+known-first-party = ["asgi-compression"]
+
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"

asgi_compression-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

asgi_compression-0.1.0/tests/test_middleware.py

@@ -0,0 +1,303 @@
+from typing import Any
+
+import pytest
+from httpx import AsyncClient
+from starlette.applications import Starlette
+from starlette.responses import PlainTextResponse
+from starlette.routing import Route
+from typing_extensions import assert_never
+
+from asgi_compression import brotli, zstd
+from asgi_compression.brotli import BrotliAlgorithm
+from asgi_compression.gzip import GzipAlgorithm
+from asgi_compression.middleware import CompressionMiddleware
+from asgi_compression.zstd import ZstdAlgorithm
+
+from .types import Encoding
+from .utils import get_test_client, unimport_module
+
+
+def determine_encoding(request: pytest.FixtureRequest) -> Encoding:
+    id_str = request.node.callspec.id
+    if "gzip" in id_str:
+        return "gzip"
+    elif "br" in id_str:
+        return "br"
+    elif "zstd" in id_str:
+        return "zstd"
+    else:
+        assert_never(id_str)
+
+
+async def test_middleware_responds_to_proper_encoding(
+    client: AsyncClient,
+    request: pytest.FixtureRequest,
+) -> None:
+    encoding = determine_encoding(request)
+    response = await client.get("/", headers={"accept-encoding": encoding})
+    assert response.status_code == 200
+    assert response.text == "x" * 4000
+    assert response.headers["Content-Encoding"] == encoding
+    assert response.headers["Vary"] == "Accept-Encoding"
+    assert int(response.headers["Content-Length"]) < 4000
+
+
+async def test_middleware_handles_identity_encoding(
+    client: AsyncClient,
+) -> None:
+    response = await client.get("/", headers={"accept-encoding": "identity"})
+    assert response.status_code == 200
+    assert response.text == "x" * 4000
+    assert "Content-Encoding" not in response.headers
+    assert response.headers["Vary"] == "Accept-Encoding"
+
+
+async def test_compression_not_in_accept_encoding(client: AsyncClient) -> None:
+    response = await client.get("/", headers={"accept-encoding": "identity"})
+    assert response.status_code == 200
+    assert response.text == "x" * 4000
+    assert "Content-Encoding" not in response.headers
+    assert response.headers["Vary"] == "Accept-Encoding"
+
+    content_length = response.headers.get("Content-Length")
+    if content_length:
+        # Django doesn't set 'Content-Length' header automatically
+        assert int(content_length) == 4000
+
+
+async def test_compression_ignored_for_small_responses(
+    client: AsyncClient,
+) -> None:
+    response = await client.get(
+        "/small_response",
+        headers={"accept-encoding": "gzip, br"},
+    )
+    expected_response = "Hello world!"
+    assert response.status_code == 200
+    assert response.text == expected_response
+    assert "Content-Encoding" not in response.headers
+    assert "Vary" not in response.headers
+
+    content_length = response.headers.get("Content-Length")
+    if content_length:
+        # Django doesn't set 'Content-Length' header automatically
+        assert int(content_length) == len(expected_response)
+
+
+async def test_compression_streaming_response(
+    client: AsyncClient,
+    request: pytest.FixtureRequest,
+) -> None:
+    encoding = determine_encoding(request)
+
+    response = await client.get(
+        "/streaming_response",
+        headers={"accept-encoding": encoding},
+    )
+    assert response.status_code == 200
+    assert response.text == "x" * 4000
+    assert response.headers["Content-Encoding"] == encoding
+    assert response.headers["Vary"] == "Accept-Encoding"
+    assert "Content-Length" not in response.headers
+
+
+async def test_compression_streaming_response_identity(
+    client: AsyncClient,
+) -> None:
+    response = await client.get(
+        "/streaming_response",
+        headers={"accept-encoding": "identity"},
+    )
+    assert response.status_code == 200
+    assert response.text == "x" * 4000
+    assert "Content-Encoding" not in response.headers
+    assert response.headers["Vary"] == "Accept-Encoding"
+    assert "Content-Length" not in response.headers
+
+
+async def test_compression_ignored_for_responses_with_encoding_set(
+    client: AsyncClient,
+) -> None:
+    response = await client.get(
+        "/streaming_response_with_content_encoding",
+        headers={"accept-encoding": "gzip, br, text"},
+    )
+    assert response.status_code == 200
+    assert response.text == "x" * 4000
+    assert response.headers["Content-Encoding"] == "text"
+    assert "Vary" not in response.headers
+    assert "Content-Length" not in response.headers
+
+
+async def test_compression_ignored_on_server_sent_events(
+    client: AsyncClient,
+) -> None:
+    async with client.stream(
+        "GET",
+        "/server_sent_events",
+        headers={"accept-encoding": "gzip, br"},
+    ) as response:
+        assert response.status_code == 200
+        assert "Content-Encoding" not in response.headers
+        assert "Content-Length" not in response.headers
+        assert response.headers["Content-Type"].startswith("text/event-stream")
+
+        current_message: dict[str, Any] = {}
+        completed_messages = []
+
+        async for line in response.aiter_lines():
+            line = line.rstrip("\r")
+
+            if not line.strip():
+                if current_message:
+                    completed_messages.append(current_message)
+
+                current_message = {}
+                continue
+
+            if ":" in line:
+                field, value = line.split(":", 1)
+                value = value[1:] if value.startswith(" ") else value
+                current_message[field] = value
+
+        for i, message in enumerate(completed_messages):
+            assert message == {
+                "id": str(i),
+                "event": "message",
+                "data": "x" * 400,
+            }
+
+
+async def test_multiple_algorithms_negotiation():
+    """Test that the middleware correctly negotiates between multiple algorithms."""
+
+    async def homepage(request):
+        return PlainTextResponse("x" * 4000)
+
+    app = Starlette(routes=[Route("/", endpoint=homepage)])
+
+    middleware = CompressionMiddleware(
+        app=app,
+        algorithms=[
+            # Order matters - first match will be used
+            BrotliAlgorithm(quality=4),
+            GzipAlgorithm(compresslevel=6),
+            ZstdAlgorithm(level=3),
+        ],
+    )
+
+    async with get_test_client(middleware) as client:
+        response = await client.get(
+            "/",
+            headers={"accept-encoding": "br, gzip, zstd"},
+        )
+        assert response.status_code == 200
+        assert response.headers["Content-Encoding"] == "br"
+
+        response = await client.get(
+            "/", headers={"accept-encoding": "gzip, zstd"}
+        )
+        assert response.status_code == 200
+        assert response.headers["Content-Encoding"] == "gzip"
+
+        response = await client.get("/", headers={"accept-encoding": "zstd"})
+        assert response.status_code == 200
+        assert response.headers["Content-Encoding"] == "zstd"
+
+        response = await client.get(
+            "/",
+            headers={"accept-encoding": "identity"},
+        )
+        assert response.status_code == 200
+        assert "Content-Encoding" not in response.headers
+
+
+async def test_custom_minimum_size():
+    """Test that the minimum size setting is respected."""
+
+    async def small_response(request):
+        return PlainTextResponse("x" * 100)
+
+    async def large_response(request):
+        return PlainTextResponse("x" * 2000)
+
+    app = Starlette(
+        routes=[
+            Route("/small", endpoint=small_response),
+            Route("/large", endpoint=large_response),
+        ]
+    )
+
+    # Set a high minimum size
+    middleware = CompressionMiddleware(
+        app=app,
+        algorithms=[GzipAlgorithm()],
+        minimum_size=1000,  # Only compress responses larger than 1KB
+    )
+
+    async with get_test_client(middleware) as client:
+        # Small response should not be compressed
+        response = await client.get(
+            "/small",
+            headers={"accept-encoding": "gzip"},
+        )
+        assert response.status_code == 200
+        assert "Content-Encoding" not in response.headers
+
+        # Large response should be compressed
+        response = await client.get(
+            "/large",
+            headers={"accept-encoding": "gzip"},
+        )
+        assert response.status_code == 200
+        assert response.headers["Content-Encoding"] == "gzip"
+
+
+async def test_zstd_compression():
+    """Test specific Zstandard compression features."""
+
+    async def homepage(request):
+        return PlainTextResponse("x" * 4000)
+
+    app = Starlette(routes=[Route("/", endpoint=homepage)])
+
+    middleware = CompressionMiddleware(app=app, algorithms=[ZstdAlgorithm()])
+
+    async with get_test_client(middleware) as client:
+        response = await client.get(
+            "/",
+            headers={"accept-encoding": "zstd"},
+        )
+        assert response.status_code == 200
+        assert response.text == "x" * 4000
+        assert response.headers["Content-Encoding"] == "zstd"
+        assert response.headers["Vary"] == "Accept-Encoding"
+        assert int(response.headers["Content-Length"]) < 4000
+
+
+def test_brotli_not_available(monkeypatch: pytest.MonkeyPatch):
+    unimport_module(
+        monkeypatch=monkeypatch,
+        module_name="brotli",
+        to_reload=brotli,
+    )
+    app = Starlette(routes=[])
+    with pytest.raises(ImportError):
+        CompressionMiddleware(
+            app=app,
+            algorithms=[BrotliAlgorithm()],
+        )
+
+
+def test_zstd_not_available(monkeypatch: pytest.MonkeyPatch):
+    unimport_module(
+        monkeypatch=monkeypatch,
+        module_name="zstandard",
+        to_reload=zstd,
+    )
+    app = Starlette(routes=[])
+    with pytest.raises(ImportError):
+        CompressionMiddleware(
+            app=app,
+            algorithms=[ZstdAlgorithm()],
+        )