bazis-async-request 2.2.3__tar.gz → 2.3.0__tar.gz

bazis_async_request-2.3.0/.github/workflows/build-publish.yml

@@ -0,0 +1,20 @@
+name: Build and Publish
+
+on:
+  push:
+    tags:
+      - 'v*.*.*'
+  # started by the Release workflow on the tag it creates: a tag pushed with the
+  # workflow token does not trigger the push event above
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+jobs:
+  build:
+    if: startsWith(github.ref, 'refs/tags/v')
+    uses: ecofuture-tech/.github/.github/workflows/reusable-build-publish.yml@main
+    secrets:
+      PYPI_TOKEN: ${{ secrets.PYPI_TOKEN }}
+      TEST_PYPI_TOKEN: ${{ secrets.TEST_PYPI_TOKEN }}

bazis_async_request-2.3.0/.github/workflows/release.yml

@@ -0,0 +1,74 @@
+name: Release
+
+# Creates the release tag vX.Y.Z on the current main commit and starts Build and Publish
+# for it. Run it from the Actions tab (or through the GitHub API) on the main branch.
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'Version without the "v" prefix, e.g. 2.3.0 or 2.4.0-rc1'
+        required: true
+        type: string
+
+permissions:
+  contents: write
+  actions: write
+
+concurrency:
+  group: release
+  cancel-in-progress: false
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    if: github.ref == 'refs/heads/main'
+    env:
+      GH_TOKEN: ${{ github.token }}
+      VERSION: ${{ inputs.version }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Validate the version
+        run: |
+          if [[ ! "$VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+(-(alpha|beta|rc)[0-9]+)?$ ]]; then
+            echo "::error::Invalid version '$VERSION', expected e.g. 2.3.0 or 2.4.0-rc1"
+            exit 1
+          fi
+          if git rev-parse -q --verify "refs/tags/v$VERSION" >/dev/null; then
+            echo "::error::Tag v$VERSION already exists"
+            exit 1
+          fi
+          LAST_TAG=$(git tag --list 'v*' --sort=-v:refname | head -n 1)
+          echo "Last release: ${LAST_TAG:-none}, new release: v$VERSION"
+          if [ -n "$LAST_TAG" ] && [ "$(printf '%s\n%s\n' "${LAST_TAG#v}" "$VERSION" | sort -V | tail -n 1)" != "$VERSION" ]; then
+            echo "::error::Version $VERSION is not newer than $LAST_TAG"
+            exit 1
+          fi
+
+      - name: Require green tests on this commit
+        run: |
+          CONCLUSION=$(gh run list --workflow tests.yml --commit "$GITHUB_SHA" --status completed \
+            --json conclusion --jq 'map(.conclusion) | first // "none"')
+          echo "Tests on $GITHUB_SHA: $CONCLUSION"
+          if [ "$CONCLUSION" != "success" ]; then
+            echo "::error::The Tests workflow has not succeeded on $GITHUB_SHA ($CONCLUSION)"
+            exit 1
+          fi
+
+      - name: Create the tag
+        run: |
+          git config user.name 'github-actions[bot]'
+          git config user.email '41898282+github-actions[bot]@users.noreply.github.com'
+          git tag -a "v$VERSION" -m "${{ github.event.repository.name }} $VERSION" "$GITHUB_SHA"
+          git push origin "v$VERSION"
+
+      - name: Start Build and Publish
+        run: gh workflow run build-publish.yml --ref "v$VERSION"
+
+      - name: Summary
+        run: |
+          echo "Tagged \`v$VERSION\` at \`$GITHUB_SHA\` and started Build and Publish." >> "$GITHUB_STEP_SUMMARY"

bazis_async_request-2.3.0/.github/workflows/tests.yml

@@ -0,0 +1,131 @@
+name: Tests
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: tests-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+      - run: uvx ruff check bazis tests
+
+  tests:
+    name: tests (python ${{ matrix.python }}, ${{ matrix.resolution }})
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    strategy:
+      fail-fast: false
+      matrix:
+        python: ['3.12', '3.13', '3.14']
+        resolution: [highest]
+        include:
+          # the lowest versions allowed by pyproject.toml
+          - python: '3.12'
+            resolution: lowest-direct
+
+    services:
+      postgres:
+        image: postgis/postgis:16-3.4
+        env:
+          POSTGRES_USER: postgres
+          POSTGRES_PASSWORD: postgres
+          POSTGRES_DB: bazis
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 5s
+          --health-timeout 5s
+          --health-retries 10
+      redis:
+        image: redis:7
+        ports:
+          - 6379:6379
+        options: >-
+          --health-cmd "redis-cli ping"
+          --health-interval 5s
+          --health-timeout 5s
+          --health-retries 10
+      kafka:
+        image: apache/kafka:3.9.1
+        ports:
+          - 9092:9092
+        options: >-
+          --health-cmd "/opt/kafka/bin/kafka-broker-api-versions.sh --bootstrap-server localhost:9092"
+          --health-interval 10s
+          --health-timeout 10s
+          --health-retries 15
+    env:
+      BS_DEBUG: 'true'
+      BS_SECRET_KEY: ci-only-secret-key-that-is-long-enough-0123456789
+      BS_DATABASES__DEFAULT__HOST: localhost
+      BS_DATABASES__DEFAULT__PORT: '5432'
+      BS_DATABASES__DEFAULT__NAME: bazis
+      BS_DATABASES__DEFAULT__USER: postgres
+      BS_DATABASES__DEFAULT__PASSWORD: postgres
+      BS_CACHES__DEFAULT__LOCATION: redis://localhost:6379/1
+      BS_MEDIA_ROOT: /tmp/bazis/media
+      BS_STATIC_ROOT: /tmp/bazis/static
+      BS_WEBAPP_ROOT: /tmp/bazis/webapp
+      BS_KAFKA_BOOTSTRAP_SERVERS: localhost:9092
+      BS_KAFKA_TOPIC_ASYNC_BG: sample_local_async_request
+      BS_KAFKA_GROUP_ID: sample_local
+      BS_KAFKA_AUTO_OFFSET_RESET: earliest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install GDAL (required by the PostGIS database backend)
+        # a stalled Ubuntu mirror must fail the step quickly instead of hanging the job
+        timeout-minutes: 10
+        run: |
+          APT="sudo apt-get -o Acquire::Retries=3 -o Acquire::http::Timeout=30 -o Acquire::https::Timeout=30"
+          $APT update
+          $APT install -y --no-install-recommends gdal-bin
+
+      - uses: astral-sh/setup-uv@v6
+        with:
+          python-version: ${{ matrix.python }}
+          activate-environment: true
+
+      - name: Install dependencies
+        run: uv pip install --resolution ${{ matrix.resolution }} -e '.[test]'
+
+      - name: Check for missing migrations
+        working-directory: sample
+        run: python manage.py makemigrations --check --dry-run
+
+      - name: Migrate the database shared by the tests and the consumer
+        # sample/settings.py sets TEST.NAME to the database name, so that the consumer sees
+        # the data of the tests; pytest runs with --reuse-db
+        working-directory: sample
+        run: |
+          python manage.py migrate -v0
+          python manage.py pgtrigger install
+
+      - name: Start a Kafka consumer
+        working-directory: sample
+        run: |
+          nohup python manage.py kafka_consumer_single > "$RUNNER_TEMP/consumer.log" 2>&1 &
+          sleep 15
+          cat "$RUNNER_TEMP/consumer.log"
+
+      - name: Run tests
+        working-directory: sample
+        run: python -m pytest ../tests -o addopts="--reuse-db" -p no:cacheprovider
+
+      - name: Consumer log
+        if: failure()
+        run: cat "$RUNNER_TEMP/consumer.log"

bazis_async_request-2.3.0/CLAUDE.md

@@ -0,0 +1,64 @@
+# bazis-async-request
+
+Background HTTP requests for Bazis: `AsyncRequestMiddleware` puts a request with
+`X-Async-Background: true` into Kafka (bazis-async-background) and answers 202 with the task
+id; the consumer (`tasks.py`) replays the request through the ASGI application, marked as
+internal in the ASGI scope (`SCOPE_INTERNAL_KEY`), and stores the response for
+`GET /async_background_response/{task_id}/`. `require_async` limits an endpoint to such
+requests.
+
+Never trust a header to recognize the requests of the consumer: clients can send any header.
+
+The package code is in `bazis/contrib/async_request`, the sample project used by the tests is in `sample/`,
+the tests are in `tests/`.
+
+## Running the tests
+
+The tests need PostgreSQL with PostGIS and Redis and Kafka (see `.github/workflows/tests.yml`).
+Run them from the `sample` directory:
+
+```bash
+cd sample
+BS_DEBUG=true \
+BS_SECRET_KEY=local-secret-key-that-is-long-enough-0123456789 \
+BS_DATABASES__DEFAULT__HOST=localhost BS_DATABASES__DEFAULT__PORT=5432 \
+BS_DATABASES__DEFAULT__NAME=bazis BS_DATABASES__DEFAULT__USER=postgres \
+BS_DATABASES__DEFAULT__PASSWORD=postgres \
+BS_CACHES__DEFAULT__LOCATION=redis://localhost:6379/1 \
+BS_MEDIA_ROOT=/tmp/bazis/media BS_STATIC_ROOT=/tmp/bazis/static BS_WEBAPP_ROOT=/tmp/bazis/webapp \
+BS_KAFKA_BOOTSTRAP_SERVERS=localhost:9092 BS_KAFKA_TOPIC_ASYNC_BG=sample_local_async_request \
+BS_KAFKA_GROUP_ID=sample_local \
+python -m pytest ../tests -o addopts="--reuse-db" -p no:cacheprovider
+```
+
+The tests and the consumer share one database (`sample/sample/settings.py` sets `TEST.NAME`
+to the database name): migrate it first (`python manage.py migrate` and
+`python manage.py pgtrigger install` in `sample`), start a consumer with the same variables
+(`python manage.py kafka_consumer_single &`) and run pytest with `-o addopts="--reuse-db"`.
+The tests marked `run_with_consumer` are skipped without Kafka settings. A local Kafka
+without Docker: download the Kafka binaries and start a single KRaft node.
+
+Lint: `ruff check bazis tests`. CI also runs `python manage.py makemigrations --check
+--dry-run` in `sample`: commit the migrations of model changes, including the sample apps.
+
+## Releasing
+
+A release is the tag `vX.Y.Z` on `main`: the Build and Publish workflow builds the package
+(the version comes from the tag through setuptools-scm) and publishes it to PyPI
+(pre-releases `-alphaN`/`-betaN`/`-rcN` go to Test PyPI) and creates the GitHub release.
+
+Claude Code sessions cannot push tags. Release through the **Release** workflow instead:
+
+1. Make sure the changes are merged into `main` and the Tests workflow is green on the
+   `main` head commit (the Release workflow checks this and refuses otherwise).
+2. Add the release notes as `docs/releases/X.Y.Z.md` in the change being released.
+3. Start the workflow `release.yml` on `ref: main` with the input `version: X.Y.Z`
+   (GitHub API: `POST /repos/ecofuture-tech/bazis-async-request/actions/workflows/release.yml/dispatches`;
+   with the GitHub MCP tools: `actions_run_trigger`, method `run_workflow`).
+4. The Release run creates the annotated tag and starts Build and Publish on it. Check
+   that both runs succeed and that the version appears on https://pypi.org/project/bazis-async-request/.
+
+Release the Bazis packages in dependency order: a package is tested in CI against the
+versions of its Bazis dependencies published on PyPI. Pick the version by semver:
+breaking changes (settings renamed or required, dependency removed, behavior changed)
+bump the minor version while the project is below 3.0.

{bazis_async_request-2.2.3 → bazis_async_request-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bazis-async-request
-Version: 2.2.3
+Version: 2.3.0
 Summary: Async Background Requests module for Bazis framework.
 Author-email: Ilya Kharyn <ilya.tt07@gmail.com>
 Maintainer-email: Ilya Kharyn <ilya.tt07@gmail.com>
@@ -17,9 +17,14 @@ Classifier: Framework :: Django
 Classifier: Framework :: FastAPI
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
-Requires-Dist: bazis-async-background
+Requires-Dist: bazis>=2.3.1
+Requires-Dist: bazis-async-background>=2.3.0
 Provides-Extra: test
-Requires-Dist: bazis-test-utils>=2.2.0; extra == "test"
+Requires-Dist: bazis-test-utils>=2.3.0; extra == "test"
+Requires-Dist: bazis-users>=2.3.0; extra == "test"
+Requires-Dist: bazis-author>=2.3.0; extra == "test"
+Requires-Dist: bazis-permit>=2.3.0; extra == "test"
+Requires-Dist: bazis-ws>=2.3.0; extra == "test"
 Provides-Extra: dev
 Requires-Dist: ruff; extra == "dev"
 
@@ -83,7 +88,7 @@ python manage.py kafka_consumer_multiple --consumers-count=5
 - **WebSocket notifications** — automatic user notification about task status
 - **API endpoint** — retrieving results by task_id
 
-**How it works**: When sending a request with the `X-Async-Request: true` header, the request is not executed immediately but is placed in the Kafka queue. The consumer retrieves the task from the queue, executes it, saves the result in Redis, and sends a notification to the user via WebSocket.
+**How it works**: When sending a request with the `X-Async-Background: true` header, the request is not executed immediately but is placed in the Kafka queue. The consumer retrieves the task from the queue, executes it, saves the result in Redis, and sends a notification to the user via WebSocket.
 
 **This package requires the installation of `bazis`, `bazis-users`, `bazis-ws` packages and running Kafka and Redis servers.**
 
@@ -127,7 +132,7 @@ This waits for the pytest container to finish and streams logs only from the Pyt
 ┌─────────────┐
 │   Client    │
 └──────┬──────┘
-       │ POST + X-Async-Request: true
+       │ POST + X-Async-Background: true
        ▼
 ┌─────────────────────┐
 │   API Endpoint      │
@@ -232,23 +237,25 @@ This adds the endpoint: `GET /api/v1/async_background_response/{task_id}/`
 ### Project-Level Middleware
 
 AsyncRequestMiddleware is registered automatically when `bazis.contrib.async_request` is loaded.
-Any request can be moved to background using the `X-Async-Request: true` header.
+Any request can be moved to background using the `X-Async-Background: true` header.
 
 **Location**: `bazis.contrib.async_request.middleware.AsyncRequestMiddleware`
 
 ### Endpoint-Only Async Request (Dependency)
 
 Use a dependency to mark specific endpoints as async-only. Such routes will return `409 Conflict`
-unless the request includes `X-Async-Request` (or an internal background call with
-`X-Async-Request-Internal: true`).
+unless the request is executed in the background (the client sends it with
+`X-Async-Background: true`, and the consumer executes it). The consumer marks its requests
+in the ASGI scope, which clients cannot forge; the former `X-Async-Background-Internal`
+header is ignored.
 
-**Location**: `bazis.contrib.async_request.dependencies.require_async`
+**Location**: `bazis.contrib.async_request.utils.require_async`
 
 #### Attach to a Single Route
 
 ```python
 from fastapi import Depends
-from bazis.contrib.async_request.dependencies import require_async
+from bazis.contrib.async_request.utils import require_async
 
 @router.post(
     "/reports/generate/",
@@ -262,12 +269,12 @@ async def generate_report(...):
 
 ```python
 from fastapi import Depends
-from bazis.contrib.async_request.dependencies import require_async
+from bazis.contrib.async_request.utils import require_async
 
 @router.post("/reports/generate/")
 async def generate_report(
     ...,
-    _async_request: None = Depends(require_async),
+    async_request: None = Depends(require_async),
 ):
     ...
 ```
@@ -297,14 +304,14 @@ Runs 5 consumers in separate processes. Suitable for local development or deploy
 
 ### Sending a Request
 
-Add the `X-Async-Request: true` header to your request:
+Add the `X-Async-Background: true` header to your request:
 
 ```bash
 curl -X POST \
   http://localhost/api/v1/orders/order/ \
   -H "Authorization: Bearer YOUR_JWT_TOKEN" \
   -H "Content-Type: application/vnd.api+json" \
-  -H "X-Async-Request: true" \
+  -H "X-Async-Background: true" \
   -d '{
     "data": {
       "type": "myapp.order",
@@ -327,11 +334,12 @@ curl -X POST \
 }
 ```
 
-If the request has no `Authorization` header, pass a channel name directly:
+A client without a user token sends an anonymous token it generated itself (16–128
+characters `A-Z a-z 0-9 _ -`, e.g. a random UUID) as `Authorization: Bearer <token>`; the same
+token subscribes to its WebSocket channel (bazis-ws) and reads the result.
 
-```bash
-X-Async-Request: <channel_name>
-```
+The request is stored in the Kafka topic with all its headers, `Authorization` included, and
+executed later with them: protect the topic accordingly.
 
 Save the `async_request_id` — this is the task identifier for retrieving the result.
 
@@ -503,7 +511,7 @@ class AsyncReportClient {
       headers: {
         'Authorization': `Bearer ${this.token}`,
         'Content-Type': 'application/vnd.api+json',
-        'X-Async-Request': 'true'
+        'X-Async-Background': 'true'
       },
       body: JSON.stringify({
         data: {
@@ -633,7 +641,7 @@ Content-Type: application/json
 # Asynchronous request (returns task_id immediately)
 POST /api/v1/generate-analytics/
 Content-Type: application/json
-X-Async-Request: true
+X-Async-Background: true
 
 {
   "report_type": "sales",

{bazis_async_request-2.2.3 → bazis_async_request-2.3.0}/README.md

@@ -58,7 +58,7 @@ python manage.py kafka_consumer_multiple --consumers-count=5
 - **WebSocket notifications** — automatic user notification about task status
 - **API endpoint** — retrieving results by task_id
 
-**How it works**: When sending a request with the `X-Async-Request: true` header, the request is not executed immediately but is placed in the Kafka queue. The consumer retrieves the task from the queue, executes it, saves the result in Redis, and sends a notification to the user via WebSocket.
+**How it works**: When sending a request with the `X-Async-Background: true` header, the request is not executed immediately but is placed in the Kafka queue. The consumer retrieves the task from the queue, executes it, saves the result in Redis, and sends a notification to the user via WebSocket.
 
 **This package requires the installation of `bazis`, `bazis-users`, `bazis-ws` packages and running Kafka and Redis servers.**
 
@@ -102,7 +102,7 @@ This waits for the pytest container to finish and streams logs only from the Pyt
 ┌─────────────┐
 │   Client    │
 └──────┬──────┘
-       │ POST + X-Async-Request: true
+       │ POST + X-Async-Background: true
        ▼
 ┌─────────────────────┐
 │   API Endpoint      │
@@ -207,23 +207,25 @@ This adds the endpoint: `GET /api/v1/async_background_response/{task_id}/`
 ### Project-Level Middleware
 
 AsyncRequestMiddleware is registered automatically when `bazis.contrib.async_request` is loaded.
-Any request can be moved to background using the `X-Async-Request: true` header.
+Any request can be moved to background using the `X-Async-Background: true` header.
 
 **Location**: `bazis.contrib.async_request.middleware.AsyncRequestMiddleware`
 
 ### Endpoint-Only Async Request (Dependency)
 
 Use a dependency to mark specific endpoints as async-only. Such routes will return `409 Conflict`
-unless the request includes `X-Async-Request` (or an internal background call with
-`X-Async-Request-Internal: true`).
+unless the request is executed in the background (the client sends it with
+`X-Async-Background: true`, and the consumer executes it). The consumer marks its requests
+in the ASGI scope, which clients cannot forge; the former `X-Async-Background-Internal`
+header is ignored.
 
-**Location**: `bazis.contrib.async_request.dependencies.require_async`
+**Location**: `bazis.contrib.async_request.utils.require_async`
 
 #### Attach to a Single Route
 
 ```python
 from fastapi import Depends
-from bazis.contrib.async_request.dependencies import require_async
+from bazis.contrib.async_request.utils import require_async
 
 @router.post(
     "/reports/generate/",
@@ -237,12 +239,12 @@ async def generate_report(...):
 
 ```python
 from fastapi import Depends
-from bazis.contrib.async_request.dependencies import require_async
+from bazis.contrib.async_request.utils import require_async
 
 @router.post("/reports/generate/")
 async def generate_report(
     ...,
-    _async_request: None = Depends(require_async),
+    async_request: None = Depends(require_async),
 ):
     ...
 ```
@@ -272,14 +274,14 @@ Runs 5 consumers in separate processes. Suitable for local development or deploy
 
 ### Sending a Request
 
-Add the `X-Async-Request: true` header to your request:
+Add the `X-Async-Background: true` header to your request:
 
 ```bash
 curl -X POST \
   http://localhost/api/v1/orders/order/ \
   -H "Authorization: Bearer YOUR_JWT_TOKEN" \
   -H "Content-Type: application/vnd.api+json" \
-  -H "X-Async-Request: true" \
+  -H "X-Async-Background: true" \
   -d '{
     "data": {
       "type": "myapp.order",
@@ -302,11 +304,12 @@ curl -X POST \
 }
 ```
 
-If the request has no `Authorization` header, pass a channel name directly:
+A client without a user token sends an anonymous token it generated itself (16–128
+characters `A-Z a-z 0-9 _ -`, e.g. a random UUID) as `Authorization: Bearer <token>`; the same
+token subscribes to its WebSocket channel (bazis-ws) and reads the result.
 
-```bash
-X-Async-Request: <channel_name>
-```
+The request is stored in the Kafka topic with all its headers, `Authorization` included, and
+executed later with them: protect the topic accordingly.
 
 Save the `async_request_id` — this is the task identifier for retrieving the result.
 
@@ -478,7 +481,7 @@ class AsyncReportClient {
       headers: {
         'Authorization': `Bearer ${this.token}`,
         'Content-Type': 'application/vnd.api+json',
-        'X-Async-Request': 'true'
+        'X-Async-Background': 'true'
       },
       body: JSON.stringify({
         data: {
@@ -608,7 +611,7 @@ Content-Type: application/json
 # Asynchronous request (returns task_id immediately)
 POST /api/v1/generate-analytics/
 Content-Type: application/json
-X-Async-Request: true
+X-Async-Background: true
 
 {
   "report_type": "sales",

bazis_async_request-2.3.0/bazis/contrib/async_request/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '2.3.0'
+__version_tuple__ = version_tuple = (2, 3, 0)
+
+__commit_id__ = commit_id = 'g7f4029675'

{bazis_async_request-2.2.3 → bazis_async_request-2.3.0}/bazis/contrib/async_request/middleware.py

@@ -27,7 +27,7 @@ from bazis.contrib.async_background.producer import enqueue_task_async
 from bazis.contrib.async_background.routes import get_async_background_response
 from bazis.contrib.async_background.utils import ChannelNameError, resolve_channel_name_async
 
-from .utils import build_request_payload
+from .utils import build_request_payload, is_internal_request
 
 
 logger = logging.getLogger(__name__)
@@ -63,10 +63,7 @@ class AsyncRequestMiddleware:
             return
 
         headers = Headers(scope=scope)
-        if (
-            headers.get("X-Async-Background-Internal", "").lower() == "true"
-            or "X-Async-Background" not in headers
-        ):
+        if is_internal_request(scope) or "X-Async-Background" not in headers:
             await self.app(scope, receive, send)
             return
 

{bazis_async_request-2.2.3 → bazis_async_request-2.3.0}/bazis/contrib/async_request/schemas.py

@@ -13,14 +13,18 @@
 # limitations under the License.
 
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field
 
 
 class AsyncRequestPayload(BaseModel):
     """Payload of a background HTTP request serialized for Kafka."""
 
-    path: str = Field(..., description="Request path")
+    path: str = Field(..., description="Request path (decoded, as in the ASGI scope)")
+    raw_path: str | None = Field(None, description="Request path as received (latin-1)")
+    root_path: str = Field("", description="ASGI root path of the application")
     query_string: str = Field(..., description="Query string")
+    #: all headers of the request (Authorization included: the request is executed with
+    #: the credentials of the client), stored in the Kafka topic
     headers: list[tuple[str | bytes, str | bytes]] = Field(
         ..., description="List of HTTP headers"
     )  # List of tuples (header_name, header_value)
@@ -31,6 +35,4 @@ class AsyncRequestPayload(BaseModel):
     scheme: str = Field(..., description="Request scheme")
     body: dict | list[dict] = Field(default_factory=dict, description="Request body")
 
-    class Config:
-        json_encoders = {bytes: lambda v: v.decode("utf-8")}
-        use_enum_values = True
+    model_config = ConfigDict(use_enum_values=True)