Prepare for v2.5.0

Author: RobertoPrevato

CHANGELOG.md

@@ -5,13 +5,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [2.5.0] - 2026-01-26
+## [2.5.0] - 2026-01-29 :copilot:
 
 - Add native HTTP/2 support to the HTTP client with automatic protocol detection
   via ALPN (Application-Layer Protocol Negotiation). The client now automatically
   uses HTTP/2 when the server supports it, with seamless fallback to HTTP/1.1.
 - Add new `HTTP2Connection` class using the `h2` library for HTTP/2 protocol handling.
-- Add new `HTTP11Connection` class using the `h11` library for consistent HTTP/1.1 handling
+- Add new `HTTP11Connection` class using the `h11` library for consistent HTTP/1.1 handling.
 - Both connection types use `asyncio.open_connection` streams for a unified architecture.
 - HTTP/2 connections support stream multiplexing, allowing multiple concurrent requests
   over a single TCP connection.
@@ -24,9 +24,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   with the HTTP/2 implementation pattern.
 - The new `HTTP11Connection` class replaces the `asyncio.Protocol`-based approach
   with a streams-based implementation.
-- Remove the legacy `ClientConnection` class has been removed.
+- Remove the legacy `ClientConnection` class.
 - Both HTTP/1.1 and HTTP/2 implementations follow the same architectural pattern.
 - Remove the option of passing the event loop to the constructor of client classes.
+- Stop using `httptools` for anything.
+- Correct bugs in the code serving static files: `HTTP 304` should not be returned for
+  `Range` requests, and handling of ranges.
 
 ## [2.4.6] - 2026-01-13
 

README.md

@@ -22,7 +22,7 @@ pip install blacksheep
 ---
 
 ```python
-from datetime import datetime
+from datetime import datetime, timezone
 
 from blacksheep import Application, get
 
@@ -31,7 +31,7 @@ app = Application()
 
 @get("/")
 async def home():
-    return f"Hello, World! {datetime.utcnow().isoformat()}"
+    return f"Hello, World! {datetime.now(timezone.utc).isoformat()}"
 
 ```
 
@@ -57,11 +57,13 @@ same sources supported by `Cookiecutter`.
 Before version `2.3.1`, BlackSheep only supported running with `CPython` and
 always depended on `httptools`. Starting with version `2.3.1`, the framework
 supports running on [`PyPy`](https://pypy.org/) and makes `httptools` an
-optional dependency. The BlackSheep HTTP Client requires either `httptools`
-(for CPython) or `h11` (for PyPy).
+optional dependency.
+
+Since version `2.5.0`, the BlackSheep HTTP Client includes HTTP/2 support and
+requires `h11` and `h2` libraries.
 
 For slightly better performance in `URL` parsing when running on `CPython`,
-it is recommended to install `httptools`.
+it is recommended to install `httptools` (optional).
 
 > [!TIP]
 >
@@ -276,7 +278,9 @@ for more details and examples.
 
 ## Client features
 
-BlackSheep includes an HTTP Client.
+BlackSheep includes an HTTP Client with native HTTP/2 support (since version `2.5.0`).
+The client automatically detects and uses HTTP/2 when the server supports it, with
+seamless fallback to HTTP/1.1.
 
 **Example:**
 ```python
@@ -297,17 +301,18 @@ asyncio.run(client_example())
 
 > [!IMPORTANT]
 >
-> Starting from version `2.3.1`, BlackSheep supports [PyPy](https://pypy.org/),
-> too (`PyPy 3.11`). For this reason, using the client requires an additional
-> dependency: `httptools` if using CPython, `h11` if using `PyPy`. This affects
-> only the `blacksheep.client` namespace.
+> Starting from version `2.3.1`, BlackSheep supports [PyPy](https://pypy.org/)
+> (`PyPy 3.11`). The HTTP client requires `h11` and `h2` libraries. Version `2.5.0`
+> added native HTTP/2 support via the `h2` library. The `httptools` library is
+> optional and only provides better URL parsing performance on CPython. These
+> dependencies affect only the `blacksheep.client` namespace.
 
 ## Supported platforms and runtimes
 
 * Python: all versions included in the [build matrix](.github/workflows/main.yml).
 * CPython and PyPy.
 * Ubuntu.
-* Windows 10.
+* Windows.
 * macOS.
 
 ## Documentation

blacksheep/client/connection.py

@@ -19,7 +19,7 @@
     WindowUpdated,
 )
 
-from blacksheep import Content, Request, Response
+from blacksheep import Content, Request, Response, StreamedContent
 
 # Compatibility for asyncio.timeout (added in Python 3.11)
 if sys.version_info >= (3, 11):
@@ -423,10 +423,23 @@ async def send(self, request: Request) -> Response:
             # Convert request to HTTP/2 headers
             h2_headers = self._convert_request_to_h2_headers(request)
 
-            # Get request body if present
+            # Determine if we should stream or materialize the body
+            # Only StreamedContent and content with unknown length can be streamed
+            use_streaming = (
+                request.content
+                and isinstance(request.content, StreamedContent)
+                and (request.content.length < 0 or request.content.body is None)
+            )
+
+            # Get request body if present (only for non-streaming content)
             body: bytes | None = None
-            if request.content:
-                body = await request.content.read()
+            if request.content and not use_streaming:
+                if request.content.body is not None:
+                    body = request.content.body
+                else:
+                    body = await request.content.read()
+
+            has_body = body is not None or use_streaming
 
             # Initialize stream tracking with completion event
             self.streams[stream_id] = StreamState(
@@ -448,19 +461,19 @@ async def send(self, request: Request) -> Response:
             )
 
             # Send headers (without end_stream if expecting 100-continue with body)
-            if expect_continue and body:
+            if expect_continue and has_body:
                 # Don't set end_stream, wait for 100 Continue
                 self.h2_conn.send_headers(stream_id, h2_headers, end_stream=False)
             else:
                 # Normal behavior
                 self.h2_conn.send_headers(
-                    stream_id, h2_headers, end_stream=(body is None or len(body) == 0)
+                    stream_id, h2_headers, end_stream=not has_body
                 )
             self.writer.write(self.h2_conn.data_to_send())
             await self.writer.drain()
 
             # Handle Expect: 100-continue
-            if expect_continue and body:
+            if expect_continue and has_body:
                 # Wait for 100 Continue response or error
                 should_send_body = await self._wait_for_100_continue_h2(stream_id)
                 if not should_send_body:
@@ -469,10 +482,27 @@ async def send(self, request: Request) -> Response:
                     self.last_used = time.time()
                     return await self._receive_response(stream_id)
 
-            # Send body if present
-            if body:
+            # Send body
+            max_frame_size = self.h2_conn.max_outbound_frame_size
+            if use_streaming:
+                # Stream the content in chunks
+                async for chunk in request.content.get_parts():
+                    if chunk:
+                        # Send chunk in frame-sized pieces
+                        for i in range(0, len(chunk), max_frame_size):
+                            frame_chunk = chunk[i : i + max_frame_size]
+                            # Don't set end_stream yet, we don't know if this is the last chunk
+                            self.h2_conn.send_data(
+                                stream_id, frame_chunk, end_stream=False
+                            )
+                            self.writer.write(self.h2_conn.data_to_send())
+                            await self.writer.drain()
+                # Send final empty frame with end_stream=True
+                self.h2_conn.send_data(stream_id, b"", end_stream=True)
+                self.writer.write(self.h2_conn.data_to_send())
+                await self.writer.drain()
+            elif body:
                 # Handle flow control for large bodies
-                max_frame_size = self.h2_conn.max_outbound_frame_size
                 for i in range(0, len(body), max_frame_size):
                     chunk = body[i : i + max_frame_size]
                     is_last = i + max_frame_size >= len(body)
@@ -932,19 +962,39 @@ def _convert_request_to_h11(
         if not has_host and request.url.host:
             headers.insert(0, (b"host", request.url.host))
 
-        # Get body
+        # Get body and handle headers
         body: bytes | None = None
+        use_chunked = False
         if request.content:
-            # For h11, we need to handle content synchronously for now
-            # The caller should have already prepared the body
-            if request.content.body is not None:
+            # Check if we should use chunked encoding (unknown length)
+            if request.content.length < 0:
+                # Streaming content with unknown length - use chunked encoding
+                use_chunked = True
+                # Add transfer-encoding header if not present
+                has_transfer_encoding = any(
+                    h[0].lower() == b"transfer-encoding" for h in headers
+                )
+                if not has_transfer_encoding:
+                    headers.append((b"transfer-encoding", b"chunked"))
+            elif request.content.body is not None:
+                # Content with known length and body already available
                 body = request.content.body
                 # Add content-length if not present
                 has_content_length = any(
                     h[0].lower() == b"content-length" for h in headers
                 )
                 if not has_content_length:
                     headers.append((b"content-length", str(len(body)).encode()))
+            else:
+                # Content with known length but body not materialized yet
+                # Add content-length from content.length if not present
+                has_content_length = any(
+                    h[0].lower() == b"content-length" for h in headers
+                )
+                if not has_content_length and request.content.length >= 0:
+                    headers.append(
+                        (b"content-length", str(request.content.length).encode())
+                    )
 
         # Create h11 Request
         method = (
@@ -985,8 +1035,16 @@ async def send(self, request: Request) -> Response:
                 # Connection is in an unusable state, reconnect
                 self._h11_conn = h11.Connection(our_role=h11.CLIENT)
 
-            # Read body if it's a coroutine/async content
-            if request.content and request.content.body is None:
+            # Determine if we need to stream or if we can send body directly
+            # Only StreamedContent can be streamed
+            use_streaming = (
+                request.content
+                and isinstance(request.content, StreamedContent)
+                and (request.content.length < 0 or request.content.body is None)
+            )
+
+            # For non-streaming content with no body, read it first
+            if request.content and request.content.body is None and not use_streaming:
                 body_data = await request.content.read()
                 # Update content with read body
                 request.content = Content(request.content.type, body_data)
@@ -999,23 +1057,32 @@ async def send(self, request: Request) -> Response:
                 h[0].lower() == b"expect" and h[1].lower() == b"100-continue"
                 for h in h11_request.headers
             )
+            has_body = body or use_streaming
 
             # Send request headers
             data = self._h11_conn.send(h11_request)
             self.writer.write(data)
             await self.writer.drain()
 
             # Handle Expect: 100-continue
-            if expect_continue and body:
+            if expect_continue and has_body:
                 # Wait for 100 Continue or error response
                 interim_response = await self._wait_for_100_continue()
                 if interim_response is not None:
                     # Got a final response (e.g., 417 Expectation Failed), don't send body
                     return interim_response
                 # Got 100 Continue or timeout, proceed to send body
 
-            # Send body if present
-            if body:
+            # Send body
+            if use_streaming:
+                # Stream the content in chunks
+                async for chunk in request.content.get_parts():
+                    if chunk:
+                        data = self._h11_conn.send(h11.Data(data=chunk))
+                        self.writer.write(data)
+                        await self.writer.drain()
+            elif body:
+                # Send body directly
                 data = self._h11_conn.send(h11.Data(data=body))
                 self.writer.write(data)
 

blacksheep/client/parser.py

@@ -68,9 +68,9 @@ def can_satisfy(self, size: int) -> bool:
         satisfy a given size.
         """
         if self._end is not None:
-            return self._end <= size
+            return self._end < size
         if self._start is not None:
-            return self._start <= size
+            return self._start < size
         raise TypeError("Expected either an end or a start")
 
     @property

blacksheep/ranges.py

@@ -11,12 +11,6 @@ from .messages cimport Message, Request, Response
 
 cdef int MAX_RESPONSE_CHUNK_SIZE
 
-cdef bytes write_request_method(Request request)
-
-cdef bytes _nocrlf(bytes value)
-
-cdef void set_headers_for_content(Message message)
-
 cdef void set_headers_for_response_content(Response message)
 
 cpdef bytes write_sse(ServerSentEvent event)