httpbinx 1.11.1__tar.gz → 1.13.0__tar.gz

{httpbinx-1.11.1 → httpbinx-1.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: httpbinx
-Version: 1.11.1
+Version: 1.13.0
 Summary: HTTP Request & Response Service, written in Python + FastAPI.
 Author-Email: Leo <imleowoo@outlook.com>
 License: MIT License
@@ -35,8 +35,8 @@ Classifier: License :: OSI Approved :: MIT License
 Project-URL: Homepage, https://github.com/imleowoo/httpbinx
 Project-URL: Repository, https://github.com/imleowoo/httpbinx
 Requires-Python: >=3.10
-Requires-Dist: fastapi
-Requires-Dist: pydantic
+Requires-Dist: fastapi<0.140.0,>=0.139.2
+Requires-Dist: pydantic<3.0.0,>=2.13.4
 Requires-Dist: uvicorn
 Requires-Dist: starlette
 Requires-Dist: jinja2

{httpbinx-1.11.1 → httpbinx-1.13.0}/pyproject.toml

@@ -11,8 +11,8 @@ description = "HTTP Request & Response Service, written in Python + FastAPI."
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
-    "fastapi",
-    "pydantic",
+    "fastapi>=0.139.2,<0.140.0",
+    "pydantic>=2.13.4,<3.0.0",
     "uvicorn",
     "starlette",
     "jinja2",
@@ -31,7 +31,7 @@ classifiers = [
     "Programming Language :: Python :: 3.14",
     "License :: OSI Approved :: MIT License",
 ]
-version = "1.11.1"
+version = "1.13.0"
 
 [project.license]
 file = "LICENSE"

{httpbinx-1.11.1 → httpbinx-1.13.0}/src/httpbinx/__init__.py

@@ -2,6 +2,6 @@
 
 from .main import app
 
-__version__ = '1.11.1'
+__version__ = '1.13.0'
 
 app.version = __version__

{httpbinx-1.11.1 → httpbinx-1.13.0}/src/httpbinx/meta.py

@@ -4,7 +4,6 @@ These tags are used to organize and categorize different endpoints in the API do
 """
 
 from functools import lru_cache
-from typing import List
 
 from pydantic import BaseModel, Field
 
@@ -19,7 +18,7 @@ class Tag(BaseModel):
 class TagsMetadata(BaseModel):
     """Container for a list of API tags."""
 
-    tags: List[Tag] = Field(..., description='List of API tags')
+    tags: list[Tag] = Field(..., description='List of API tags')
 
 
 TAGS_METADATA = TagsMetadata(
@@ -40,7 +39,7 @@ TAGS_METADATA = TagsMetadata(
 
 
 @lru_cache
-def get_tags_metadata() -> List[dict]:
+def get_tags_metadata() -> list[dict]:
     """
     Returns the tags metadata in the format expected by FastAPI.
     """

{httpbinx-1.11.1 → httpbinx-1.13.0}/src/httpbinx/routers/anything.py

@@ -21,12 +21,35 @@ class BombTypes(str, Enum):
 bombs_path: Path = get_bomb_file_path()
 
 
-@router.api_route(
-    '/anything',  # TODO path regex
+@router.get(
+    '/anything',
+    response_model=RequestInfo,
+    summary='Returns anything passed in request data.',
+    response_description='Anything passed in request',
+)
+@router.post(
+    '/anything',
+    response_model=RequestInfo,
+    summary='Returns anything passed in request data.',
+    response_description='Anything passed in request',
+)
+@router.put(
+    '/anything',
+    response_model=RequestInfo,
+    summary='Returns anything passed in request data.',
+    response_description='Anything passed in request',
+)
+@router.delete(
+    '/anything',
+    response_model=RequestInfo,
+    summary='Returns anything passed in request data.',
+    response_description='Anything passed in request',
+)
+@router.patch(
+    '/anything',
     response_model=RequestInfo,
     summary='Returns anything passed in request data.',
     response_description='Anything passed in request',
-    methods=['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'TRACE'],
 )
 async def anything(request: Request):
     return await to_request_info(request)

{httpbinx-1.11.1 → httpbinx-1.13.0}/src/httpbinx/routers/auth.py

@@ -1,6 +1,8 @@
 """Auth"""
 
-from fastapi import APIRouter, HTTPException
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, HTTPException
 from fastapi.security import HTTPBasic, HTTPBasicCredentials
 
 router = APIRouter(
@@ -14,8 +16,8 @@ security = HTTPBasic()
     summary='Prompts the user for authorization using HTTP Basic Auth.',
     response_description='TODO',
 )
-async def basic_auth(user: str, password: str, credentials: HTTPBasicCredentials = security):
+async def basic_auth(user: str, password: str, credentials: Annotated[HTTPBasicCredentials, Depends(security)]):
     if not (credentials and credentials.username == user and credentials.password == password):
-        raise HTTPException(status_code=401)
+        raise HTTPException(status_code=401, headers={'WWW-Authenticate': 'Basic'})
 
     return {'authenticated': True, 'user': user}

{httpbinx-1.11.1 → httpbinx-1.13.0}/src/httpbinx/routers/dynamicdata.py

@@ -3,6 +3,7 @@
 import asyncio
 import base64
 import binascii
+import math
 import random
 import uuid
 
@@ -18,6 +19,10 @@ from httpbinx.schemas import RequestInfo
 
 router = APIRouter(tags=['Dynamic data'])
 
+# Upper bound on the number of chunks /drip yields so large payloads keep a
+# meaningful pause between chunks instead of sleeping once per byte.
+DRIP_MAX_CHUNKS = 100
+
 
 class OctetStreamResponse(Response):
     """set response headers Content-Type: application/octet-stream"""
@@ -67,9 +72,32 @@ async def random_bytes(
     return OctetStreamResponse(content=content)  # TODO use StreamingResponse
 
 
-@router.api_route(
+@router.get(
+    '/delay/{delay}',
+    response_model=RequestInfo,
+    summary='Returns a delayed response (max of 10 seconds).',
+    response_description='A delayed response.',
+)
+@router.post(
+    '/delay/{delay}',
+    response_model=RequestInfo,
+    summary='Returns a delayed response (max of 10 seconds).',
+    response_description='A delayed response.',
+)
+@router.put(
+    '/delay/{delay}',
+    response_model=RequestInfo,
+    summary='Returns a delayed response (max of 10 seconds).',
+    response_description='A delayed response.',
+)
+@router.delete(
+    '/delay/{delay}',
+    response_model=RequestInfo,
+    summary='Returns a delayed response (max of 10 seconds).',
+    response_description='A delayed response.',
+)
+@router.patch(
     '/delay/{delay}',
-    methods=['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'TRACE'],
     response_model=RequestInfo,
     summary='Returns a delayed response (max of 10 seconds).',
     response_description='A delayed response.',
@@ -86,7 +114,7 @@ async def delay_response(*, delay: float = Path(..., ge=0, le=10, description='d
     response_description='A dripped response.',
 )
 async def drip(
-    duration: float = Query(default=2, description='The amount of time (in seconds) over which to drip each byte'),
+    duration: float = Query(default=2, description='The amount of time (in seconds) over which to drip the response'),
     numbytes: int = Query(
         default=10,
         gt=0,
@@ -97,12 +125,19 @@ async def drip(
     delay: float = Query(default=2, ge=0, description='The amount of time (in seconds) to delay before responding'),
 ):
     await asyncio.sleep(delay)
+    # Drip in chunks so large `numbytes` do not turn into a burst of zero-length
+    # sleeps. The whole payload is paced over `duration` regardless of `numbytes`.
+    chunk_size = max(1, math.ceil(numbytes / DRIP_MAX_CHUNKS))
+    num_chunks = math.ceil(numbytes / chunk_size)
     # Number of seconds to pause during each data generation
-    pause = int(duration / numbytes)
+    pause = duration / num_chunks
 
     async def generate_content():
-        for _ in range(numbytes):
-            yield b'*'
+        remaining = numbytes
+        while remaining > 0:
+            chunk = min(chunk_size, remaining)
+            remaining -= chunk
+            yield b'*' * chunk
             await asyncio.sleep(pause)
 
     return StreamingResponse(content=generate_content(), media_type='application/octet-stream', status_code=code)

{httpbinx-1.11.1 → httpbinx-1.13.0}/src/httpbinx/routers/images.py

@@ -28,8 +28,7 @@ router = APIRouter(tags=['Images'], default_response_class=ImageResponse)
     response_description='An image.',
 )
 async def image(request: Request):
-    accept = request.headers.get('accept')
-    accept = accept.lower()
+    accept = (request.headers.get('accept') or '').lower()
     if 'image/webp' in accept:
         return await image_webp()
     elif 'image/svg+xml' in accept:

{httpbinx-1.11.1 → httpbinx-1.13.0}/src/httpbinx/routers/inspection/response.py

@@ -1,7 +1,7 @@
 import uuid
 from email.utils import formatdate
 
-from fastapi import APIRouter, Path
+from fastapi import APIRouter, Path, Response
 from starlette import status
 from starlette.requests import Request
 
@@ -19,14 +19,13 @@ router = APIRouter(
     ' is present. Returns the same as a GET otherwise.',
     response_description='TODO',
 )
-async def cache(request: Request):
+async def cache(request: Request, response: Response):
     # https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Headers/If-Modified-Since
     is_conditional = request.headers.get('If-Modified-Since') or request.headers.get('If-None-Match')
     if is_conditional is None:
-        response = await httpmethods.get(request)
         response.headers['Last-Modified'] = formatdate()
         response.headers['ETag'] = uuid.uuid4().hex
-        return response
+        return await httpmethods.get(request)
     else:
         return status_code_response(status.HTTP_304_NOT_MODIFIED)
 
@@ -34,17 +33,18 @@ async def cache(request: Request):
 @router.get(
     '/cache/{value}', summary='Sets a Cache-Control header for n seconds.', response_description='Cache control set'
 )
-async def cache_control(*, value: int = Path(..., title='Cache-Control max-age value'), request: Request):
-    response = await httpmethods.get(request)
+async def cache_control(
+    *, value: int = Path(..., title='Cache-Control max-age value'), request: Request, response: Response
+):
     response.headers['Cache-Control'] = f'public, max-age={value}'
-    return response
+    return await httpmethods.get(request)
 
 
 @router.get(
     '/etag/{etag}',
     summary='Assumes the resource has the given etag and responds to If-None-Match and If-Match headers appropriately.',
 )
-async def set_etag(*, etag: str = Path(..., title='ETag value'), request: Request):
+async def set_etag(*, etag: str = Path(..., title='ETag value'), request: Request, response: Response):
     # TODO set If-None-Match
     # https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Headers/If-None-Match
     if_none_match = parse_multi_value_header(request.headers.get('If-None-Match'))
@@ -59,9 +59,8 @@ async def set_etag(*, etag: str = Path(..., title='ETag value'), request: Reques
         if etag not in if_match and '*' not in if_match:
             return status_code_response(status.HTTP_412_PRECONDITION_FAILED)
     # Special cases don't apply, return normal response
-    response = await httpmethods.get(request)
     response.headers['ETag'] = etag
-    return response
+    return await httpmethods.get(request)
 
 
 @router.api_route(

{httpbinx-1.11.1 → httpbinx-1.13.0}/src/httpbinx/routers/redirects.py

@@ -28,9 +28,32 @@ async def absolute_redirect_n_times(*, n: int = Path(..., title='Redirects n tim
     return _redirect(request, type_=RedirectTypes.ABSOLUTE, n=n)
 
 
-@router.api_route(
+@router.get(
+    '/redirect-to',
+    summary='302/3XX Redirects to the given URL.',
+    response_description='A redirection.',
+    response_class=Response,
+)
+@router.post(
+    '/redirect-to',
+    summary='302/3XX Redirects to the given URL.',
+    response_description='A redirection.',
+    response_class=Response,
+)
+@router.put(
+    '/redirect-to',
+    summary='302/3XX Redirects to the given URL.',
+    response_description='A redirection.',
+    response_class=Response,
+)
+@router.delete(
+    '/redirect-to',
+    summary='302/3XX Redirects to the given URL.',
+    response_description='A redirection.',
+    response_class=Response,
+)
+@router.patch(
     '/redirect-to',
-    methods=['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'TRACE'],
     summary='302/3XX Redirects to the given URL.',
     response_description='A redirection.',
     response_class=Response,

{httpbinx-1.11.1 → httpbinx-1.13.0}/src/httpbinx/schemas.py

@@ -1,7 +1,7 @@
 import json
 from enum import Enum
 from functools import lru_cache
-from typing import AnyStr, Dict, Union
+from typing import Any
 
 from pydantic import AnyHttpUrl, BaseModel, Field
 from starlette.requests import Request
@@ -33,15 +33,15 @@ class RequestInfo(BaseModel):
     """
 
     url: AnyHttpUrl = Field(title='Request URL')
-    args: Dict = Field(default_factory=dict, title='Request Args')
-    headers: Dict = Field(default_factory=dict, title='Request Headers')
-    origin: AnyStr = Field('', title="Client's IP")
-    form: Dict = Field(default_factory=dict, title='Request Form')
-    data: Union[str, bytes] = Field(b'', title='Request Data')
-    files: Dict = Field(default_factory=dict, title='Upload Files')
-    json_data: AnyStr = Field('', alias='json', title='Content-Type: application/json', description='serialized')
+    args: dict[str, Any] = Field(default_factory=dict, title='Request Args')
+    headers: dict[str, str] = Field(default_factory=dict, title='Request Headers')
+    origin: str = Field('', title="Client's IP")
+    form: dict[str, Any] = Field(default_factory=dict, title='Request Form')
+    data: str | bytes = Field(b'', title='Request Data')
+    files: dict[str, Any] = Field(default_factory=dict, title='Upload Files')
+    json_data: str = Field('', alias='json', title='Content-Type: application/json', description='serialized')
     method: HTTPMethod = Field(HTTPMethod.get, title='HTTP Request Method')
-    extras: Dict = Field(default_factory=dict, title='The Other Information')
+    extras: dict[str, Any] = Field(default_factory=dict, title='The Other Information')
 
     @classmethod
     def get_properties(cls):
@@ -49,7 +49,7 @@ class RequestInfo(BaseModel):
 
         @lru_cache
         def properties():
-            return tuple(cls.schema()['properties'].keys())
+            return tuple(cls.model_json_schema()['properties'].keys())
 
         return properties()
 
@@ -81,11 +81,14 @@ class RequestAttrs:
         If there are more than one value
         for a key, the result will have a list of values for the key.
         Otherwise it will have the plain value."""
-        out = dict()
+        out = {}
         for k, v in self.request.query_params.multi_items():
-            exist = out.get(k)
-            if exist:
-                out[k] = exist.append(v) if isinstance(exist, list) else [exist, v]
+            if k in out:
+                existing = out[k]
+                if isinstance(existing, list):
+                    existing.append(v)
+                else:
+                    out[k] = [existing, v]
             else:
                 out[k] = v
         return out

{httpbinx-1.11.1 → httpbinx-1.13.0}/tests/test_anything.py

@@ -7,11 +7,16 @@ class TestAnything:
     """Tests for the /anything endpoint."""
 
     def test_all_methods(self, client):
-        for method in ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'TRACE']:
+        for method in ['GET', 'POST', 'PUT', 'DELETE', 'PATCH']:
             response = client.request(method=method, url='/anything')
             assert response.status_code == status.HTTP_200_OK
             assert response.json()['method'] == method
 
+    def test_trace_is_not_allowed(self, client):
+        response = client.request(method='TRACE', url='/anything')
+
+        assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED
+
     def test_with_body(self, client):
         response = client.post('/anything', json={'hello': 'world'})
         assert response.status_code == status.HTTP_200_OK

{httpbinx-1.11.1 → httpbinx-1.13.0}/tests/test_auth.py

@@ -2,11 +2,9 @@
 
 from base64 import b64encode
 
-import pytest
 from starlette import status
 
 
-@pytest.mark.xfail(reason='Source bug: HTTPBasic not used correctly in auth endpoint - missing Depends()')
 def test_basic_auth_valid(client):
     credentials = b64encode(b'admin:secret').decode()
     response = client.get('/basic-auth/admin/secret', headers={'Authorization': f'Basic {credentials}'})
@@ -14,14 +12,14 @@ def test_basic_auth_valid(client):
     assert response.json() == {'authenticated': True, 'user': 'admin'}
 
 
-@pytest.mark.xfail(reason='Source bug: HTTPBasic not used correctly in auth endpoint - missing Depends()')
 def test_basic_auth_wrong_password(client):
     credentials = b64encode(b'admin:wrong').decode()
     response = client.get('/basic-auth/admin/secret', headers={'Authorization': f'Basic {credentials}'})
     assert response.status_code == status.HTTP_401_UNAUTHORIZED
+    assert response.headers['www-authenticate'] == 'Basic'
 
 
-@pytest.mark.xfail(reason='Source bug: HTTPBasic not used correctly in auth endpoint - missing Depends()')
 def test_basic_auth_missing_header(client):
     response = client.get('/basic-auth/admin/secret')
     assert response.status_code == status.HTTP_401_UNAUTHORIZED
+    assert response.headers['www-authenticate'] == 'Basic'

{httpbinx-1.11.1 → httpbinx-1.13.0}/tests/test_dynamic_data.py

@@ -65,6 +65,45 @@ class TestDrip:
         assert response.status_code == status.HTTP_200_OK
         assert len(response.content) == 5
 
+    def test_respects_duration(self, client):
+        duration = 0.2
+        start = time.time()
+        response = client.get(f'/drip?duration={duration}&numbytes=10&delay=0')
+        elapsed = time.time() - start
+        assert response.status_code == status.HTTP_200_OK
+        assert len(response.content) == 10
+        assert elapsed >= duration
+
+    def test_large_numbytes_is_paced(self, client):
+        duration = 0.2
+        numbytes = 100_000
+        start = time.time()
+        response = client.get(f'/drip?duration={duration}&numbytes={numbytes}&delay=0')
+        elapsed = time.time() - start
+        assert response.status_code == status.HTTP_200_OK
+        assert len(response.content) == numbytes
+        assert elapsed >= duration
+
+    def test_large_numbytes_drips_without_per_byte_sleeps(self, client, monkeypatch):
+        import asyncio as asyncio_module
+        import types
+
+        from httpbinx.routers import dynamicdata
+
+        delays = []
+
+        async def fake_sleep(delay):
+            delays.append(delay)
+            await asyncio_module.sleep(0)
+
+        monkeypatch.setattr(dynamicdata, 'asyncio', types.SimpleNamespace(sleep=fake_sleep))
+
+        response = client.get('/drip?duration=1&numbytes=100_000&delay=0')
+        assert response.status_code == status.HTTP_200_OK
+        assert len(response.content) == 100_000
+        # One sleep for the initial delay plus a bounded number of chunk sleeps.
+        assert len(delays) <= 101
+
 
 class TestLinks:
     """Tests for the /links endpoint."""

{httpbinx-1.11.1 → httpbinx-1.13.0}/tests/test_http_methods.py

@@ -25,6 +25,10 @@ class TestGet:
         response = client.get('/get?foo=bar&baz=1')
         assert response.json()['args'] == {'foo': 'bar', 'baz': '1'}
 
+    def test_with_repeated_query_params(self, client):
+        response = client.get('/get?tag=python&tag=fastapi&tag=pydantic')
+        assert response.json()['args'] == {'tag': ['python', 'fastapi', 'pydantic']}
+
 
 class TestPost:
     """Tests for POST /post."""

{httpbinx-1.11.1 → httpbinx-1.13.0}/tests/test_images.py

@@ -44,6 +44,14 @@ def test_image_accept_not_acceptable(client):
     assert response.status_code == status.HTTP_406_NOT_ACCEPTABLE
 
 
+def test_image_without_accept_header_is_not_acceptable(client):
+    client.headers.pop('accept')
+
+    response = client.get('/image')
+
+    assert response.status_code == status.HTTP_406_NOT_ACCEPTABLE
+
+
 def test_image_png(client):
     response = client.get('/image/png')
     assert response.status_code == status.HTTP_200_OK

httpbinx-1.13.0/tests/test_openapi.py

@@ -0,0 +1,23 @@
+"""OpenAPI schema tests."""
+
+
+def test_multi_method_routes_have_unique_operation_ids(client):
+    """Every documented operation for a multi-method endpoint has a unique ID."""
+    schema = client.get('/openapi.json').json()
+    paths = ['/anything', '/delay/{delay}', '/redirect-to']
+    operation_ids = [
+        operation['operationId']
+        for path in paths
+        for operation in schema['paths'][path].values()
+        if isinstance(operation, dict) and 'operationId' in operation
+    ]
+
+    assert len(operation_ids) == len(set(operation_ids))
+
+
+def test_multi_method_routes_do_not_document_trace(client):
+    """TRACE is not part of httpbinx's public API."""
+    schema = client.get('/openapi.json').json()
+    paths = ['/anything', '/delay/{delay}', '/redirect-to']
+
+    assert all('trace' not in schema['paths'][path] for path in paths)

httpbinx-1.13.0/tests/test_response_inspection.py

@@ -0,0 +1,50 @@
+from email.utils import parsedate_to_datetime
+
+import pytest
+
+
+def test_cache_emits_validators_without_mutating_request_headers(client):
+    response = client.get('/cache?name=value', headers={'X-Probe': 'preserved'})
+    assert response.status_code == 200
+    assert parsedate_to_datetime(response.headers['Last-Modified'])
+    assert response.headers['ETag']
+    body = response.json()
+    assert body['args'] == {'name': 'value'}
+    assert body['headers']['x-probe'] == 'preserved'
+    assert 'Last-Modified' not in body['headers']
+    assert 'ETag' not in body['headers']
+    for header in ['If-Modified-Since', 'If-None-Match']:
+        conditional = client.get('/cache', headers={header: response.headers['ETag']})
+        assert conditional.status_code == 304
+        assert conditional.content == b''
+
+
+@pytest.mark.parametrize('seconds', [0, 60, 3600])
+def test_cache_control_is_an_http_header(client, seconds):
+    response = client.get(f'/cache/{seconds}', headers={'Cache-Control': 'no-cache'})
+    assert response.status_code == 200
+    assert response.headers['Cache-Control'] == f'public, max-age={seconds}'
+    assert response.json()['headers']['cache-control'] == 'no-cache'
+    assert 'Cache-Control' not in response.json()['headers']
+
+
+@pytest.mark.parametrize(
+    ('headers', 'status_code'),
+    [
+        ({}, 200),
+        ({'If-None-Match': 'other'}, 200),
+        ({'If-Match': 'probe'}, 200),
+        ({'If-None-Match': 'probe'}, 304),
+        ({'If-None-Match': '*'}, 304),
+        ({'If-Match': 'other'}, 412),
+    ],
+)
+def test_etag_response_header_and_existing_conditions(client, headers, status_code):
+    response = client.get('/etag/probe', headers=headers)
+    assert response.status_code == status_code
+    if status_code in [200, 304]:
+        assert response.headers['ETag'] == 'probe'
+    if status_code == 200:
+        assert 'ETag' not in response.json()['headers']
+    elif status_code == 304:
+        assert response.content == b''

httpbinx-1.13.0/tests/test_schemas.py

@@ -0,0 +1,26 @@
+"""Schema tests."""
+
+import warnings
+
+from pydantic import PydanticDeprecatedSince20
+
+from httpbinx.schemas import RequestInfo
+
+
+def test_request_info_properties_do_not_use_deprecated_pydantic_schema_api():
+    with warnings.catch_warnings():
+        warnings.simplefilter('error', PydanticDeprecatedSince20)
+        properties = RequestInfo.get_properties()
+
+    assert properties == (
+        'url',
+        'args',
+        'headers',
+        'origin',
+        'form',
+        'data',
+        'files',
+        'json',
+        'method',
+        'extras',
+    )