fast-priority 0.0.14__tar.gz

fast_priority-0.0.14/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Korbinian Schweiger
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fast_priority-0.0.14/PKG-INFO

@@ -0,0 +1,139 @@
+Metadata-Version: 2.4
+Name: fast-priority
+Version: 0.0.14
+Summary: Simple and streigt forward priority queing gateway using fastapi
+Keywords: queue,fastapi,priority,redis
+Author-email: Korbinian Schweiger <korbinian.schweiger@gmail.com>
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Framework :: FastAPI
+Classifier: Intended Audience :: System Administrators
+Classifier: Topic :: Internet
+License-File: LICENSE
+Requires-Dist: fastapi[standard]>=0.115.8
+Requires-Dist: httpx
+Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: rq>=2.1.0
+Requires-Dist: click
+Requires-Dist: uvicorn>=0.34.0
+
+# 🚀 Fast Priority Queue 🔥
+
+A minimal priority queuing gateway built with FastAPI using Redis.
+
+It is designed to sit between your clients and a backend REST API, managing two priority levels—high and low—using the [`rq` package](https://python-rq.org/). Requests are enqueued based on the request path and processed synchronously by dedicated worker processes, so the overall throughput is limited by the number of workers.
+
+## Overview
+
+- Intercepts incoming client requests and forwards them to a target REST API.
+- Enqueues requests into either a high-priority or low-priority queue based on configurable path matching.
+- Processes queued requests via worker processes running in a separate environment.
+- Offers Dockerized deployment for both the gateway and worker processes.
+
+
+## Configuration ⚙️
+
+Both the gateway and workers are fully configurable via the following environment variables.
+
+### Gateway
+
+| ENV                                       | Description                                                                                                                                | Required | Default   |
+|-------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------|----------|-----------|
+| FAST_PRIORITY_TARGET_BASE_URL       | Base url of the target REST api which should run behind the gateway                                                                        | x        |           |
+| FAST_PRIORITY_HIGH_PRIO_PATHS       | Switch between **listed** and **unlisted** modes. If **listed** (**unlisted**) the paths defined in the _PATH_ env variables are put on the **high** (**low**) queue |          | unlisted  |
+| FAST_PRIORITY_PRIO_PATHS            | Comma separated list of paths on the target API that should have low priority. Low priority for exact matches                              |          | None      |
+| FAST_PRIORITY_PRIO_BASE_PATHS       | Comma separated list of paths on the target API that should have low priority. Low priority if a request paths starts with the value.      |          | None      |
+| FAST_PRIORITY_PASS_THROUGH          | Comma separated list of paths on the target API that should skip the queue. Request will be directly be passed on.                         |          | health/   |
+| FAST_PRIORITY_POLL_INTERVAL         | How often should each request check if the job is finished                                                                                 |          | 1.0       |
+| FAST_PRIORITY_TTL                   | Time-to-live (in seconds) for jobs on the queues.	                                                                                         |          | 300       |
+| FAST_PRIORITY_REDIS_HOST            | Redis host                                                                                                                                 |          | localhost |
+| FAST_PRIORITY_REDIS_PORT            | Redis port                                                                                                                                 |          | 6379      |
+| FAST_PRIORITY_REDIS_USER            | Redis username                                                                                                                             |          | None      |
+| FAST_PRIORITY_REDIS_PASSWORD        | Redis password                                                                                                                             |          | None      |
+
+### Queue worker (docker)
+
+| ENV                                 | Description                                                                                                                           | Required | Default   |
+|-------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------|----------|-----------|
+| FAST_PRIORITY_WORKERS               | Set (e.g., non-empty or a number) to run as a worker instead of the gateway. Controls the number of worker processes to launch.       | x        |           |
+| FAST_PRIORITY_REDIS_HOST            | Redis host                                                                                                                            |          | localhost |
+| FAST_PRIORITY_REDIS_PORT            | Redis port                                                                                                                            |          | 6379      |
+| FAST_PRIORITY_REDIS_USER            | Redis username                                                                                                                        |          | None      |
+| FAST_PRIORITY_REDIS_PASSWORD        | Redis password                                                                                                                        |          | None      |
+
+## Usage
+
+Fast Priority Queue is designed to run via Docker (or Docker Compose) or using the script installed with the package `run-fast-priority`. The configuration works the same for both approaches using the environment variables described in [Configuration section](#configuration). The script is mainly provide to give the user the flexibility to include the gateway in their own docker containers by installing the package via pypi.
+
+For development (or more specialized application) the gateway can also be run using the underlying command like this:
+
+```bash
+fastapi run fast_priority/app.py --host 0.0.0.0 --port 8001
+rq worker high low
+```
+
+### Docker 🐳
+
+You can build the Docker container using the provided Dockerfile. The container adapts its run mode based on the presence of the environment variable `FAST_PRIORITY_WORKER`:
+
+- If `FAST_PRIORITY_WORKER` is set, the container starts the worker(s).
+- If not, the gateway is started.
+
+The same strategy can be used with you own container and installing the package in the Dockerfile from pypi.
+
+
+#### Examples
+
+```bash
+# API
+docker run -p 8010:8000 -e FAST_PRIORITY_TARGET_BASE_URL=http://localhost:8011 -e FAST_PRIORITY_REDIS_HOST=localhost fast_priority:latest
+
+# Workers
+docker run -p 8010:8000 -e  FAST_PRIORITY_WORKER=1 -e FAST_PRIORITY_REDIS_HOST=localhost fast_priority:latest
+```
+
+
+#### Compose 🐳🐳🐳
+
+The simplest way to run Fast Priority Queue and its dependencies is via Docker Compose. Below is an example configuration:
+
+```yml
+services:
+  behind_gateway_api:
+    ...
+  priorityity-gateway:
+    image: fast_priority:latest
+    environment:
+      - FAST_PRIORITY_TARGET_BASE_URL=http://behind_gateway_api:8000
+      - FAST_PRIORITY_REDIS_HOST=queue
+      - FAST_PRIORITY_PRIO_PATHS=endpoint_1,endpoint_2
+    ports:
+      - 8066:8000
+
+  priority-gateway-worker:
+    image: fast_priority:latest
+    environment:
+      - FAST_PRIORITY_WORKERS=1
+      - FAST_PRIORITY_REDIS_HOST=queue
+    networks:
+      - default
+  queue:
+    image: redis
+    networks:
+      - default
+
+networks:
+  default:
+    driver: bridge
+
+```
+
+
+## Contributing
+Contributions to Fast Priority Queue are welcome! Feel free to open issues or submit pull requests with improvements, bug fixes, or feature suggestions.
+
+

fast_priority-0.0.14/README.md

@@ -0,0 +1,115 @@
+# 🚀 Fast Priority Queue 🔥
+
+A minimal priority queuing gateway built with FastAPI using Redis.
+
+It is designed to sit between your clients and a backend REST API, managing two priority levels—high and low—using the [`rq` package](https://python-rq.org/). Requests are enqueued based on the request path and processed synchronously by dedicated worker processes, so the overall throughput is limited by the number of workers.
+
+## Overview
+
+- Intercepts incoming client requests and forwards them to a target REST API.
+- Enqueues requests into either a high-priority or low-priority queue based on configurable path matching.
+- Processes queued requests via worker processes running in a separate environment.
+- Offers Dockerized deployment for both the gateway and worker processes.
+
+
+## Configuration ⚙️
+
+Both the gateway and workers are fully configurable via the following environment variables.
+
+### Gateway
+
+| ENV                                       | Description                                                                                                                                | Required | Default   |
+|-------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------|----------|-----------|
+| FAST_PRIORITY_TARGET_BASE_URL       | Base url of the target REST api which should run behind the gateway                                                                        | x        |           |
+| FAST_PRIORITY_HIGH_PRIO_PATHS       | Switch between **listed** and **unlisted** modes. If **listed** (**unlisted**) the paths defined in the _PATH_ env variables are put on the **high** (**low**) queue |          | unlisted  |
+| FAST_PRIORITY_PRIO_PATHS            | Comma separated list of paths on the target API that should have low priority. Low priority for exact matches                              |          | None      |
+| FAST_PRIORITY_PRIO_BASE_PATHS       | Comma separated list of paths on the target API that should have low priority. Low priority if a request paths starts with the value.      |          | None      |
+| FAST_PRIORITY_PASS_THROUGH          | Comma separated list of paths on the target API that should skip the queue. Request will be directly be passed on.                         |          | health/   |
+| FAST_PRIORITY_POLL_INTERVAL         | How often should each request check if the job is finished                                                                                 |          | 1.0       |
+| FAST_PRIORITY_TTL                   | Time-to-live (in seconds) for jobs on the queues.	                                                                                         |          | 300       |
+| FAST_PRIORITY_REDIS_HOST            | Redis host                                                                                                                                 |          | localhost |
+| FAST_PRIORITY_REDIS_PORT            | Redis port                                                                                                                                 |          | 6379      |
+| FAST_PRIORITY_REDIS_USER            | Redis username                                                                                                                             |          | None      |
+| FAST_PRIORITY_REDIS_PASSWORD        | Redis password                                                                                                                             |          | None      |
+
+### Queue worker (docker)
+
+| ENV                                 | Description                                                                                                                           | Required | Default   |
+|-------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------|----------|-----------|
+| FAST_PRIORITY_WORKERS               | Set (e.g., non-empty or a number) to run as a worker instead of the gateway. Controls the number of worker processes to launch.       | x        |           |
+| FAST_PRIORITY_REDIS_HOST            | Redis host                                                                                                                            |          | localhost |
+| FAST_PRIORITY_REDIS_PORT            | Redis port                                                                                                                            |          | 6379      |
+| FAST_PRIORITY_REDIS_USER            | Redis username                                                                                                                        |          | None      |
+| FAST_PRIORITY_REDIS_PASSWORD        | Redis password                                                                                                                        |          | None      |
+
+## Usage
+
+Fast Priority Queue is designed to run via Docker (or Docker Compose) or using the script installed with the package `run-fast-priority`. The configuration works the same for both approaches using the environment variables described in [Configuration section](#configuration). The script is mainly provide to give the user the flexibility to include the gateway in their own docker containers by installing the package via pypi.
+
+For development (or more specialized application) the gateway can also be run using the underlying command like this:
+
+```bash
+fastapi run fast_priority/app.py --host 0.0.0.0 --port 8001
+rq worker high low
+```
+
+### Docker 🐳
+
+You can build the Docker container using the provided Dockerfile. The container adapts its run mode based on the presence of the environment variable `FAST_PRIORITY_WORKER`:
+
+- If `FAST_PRIORITY_WORKER` is set, the container starts the worker(s).
+- If not, the gateway is started.
+
+The same strategy can be used with you own container and installing the package in the Dockerfile from pypi.
+
+
+#### Examples
+
+```bash
+# API
+docker run -p 8010:8000 -e FAST_PRIORITY_TARGET_BASE_URL=http://localhost:8011 -e FAST_PRIORITY_REDIS_HOST=localhost fast_priority:latest
+
+# Workers
+docker run -p 8010:8000 -e  FAST_PRIORITY_WORKER=1 -e FAST_PRIORITY_REDIS_HOST=localhost fast_priority:latest
+```
+
+
+#### Compose 🐳🐳🐳
+
+The simplest way to run Fast Priority Queue and its dependencies is via Docker Compose. Below is an example configuration:
+
+```yml
+services:
+  behind_gateway_api:
+    ...
+  priorityity-gateway:
+    image: fast_priority:latest
+    environment:
+      - FAST_PRIORITY_TARGET_BASE_URL=http://behind_gateway_api:8000
+      - FAST_PRIORITY_REDIS_HOST=queue
+      - FAST_PRIORITY_PRIO_PATHS=endpoint_1,endpoint_2
+    ports:
+      - 8066:8000
+
+  priority-gateway-worker:
+    image: fast_priority:latest
+    environment:
+      - FAST_PRIORITY_WORKERS=1
+      - FAST_PRIORITY_REDIS_HOST=queue
+    networks:
+      - default
+  queue:
+    image: redis
+    networks:
+      - default
+
+networks:
+  default:
+    driver: bridge
+
+```
+
+
+## Contributing
+Contributions to Fast Priority Queue are welcome! Feel free to open issues or submit pull requests with improvements, bug fixes, or feature suggestions.
+

fast_priority-0.0.14/fast_priority/app.py

@@ -0,0 +1,219 @@
+import asyncio
+import logging
+import os
+from contextlib import asynccontextmanager
+from enum import StrEnum
+from typing import Any
+
+import httpx
+from dotenv import load_dotenv
+from fastapi import FastAPI, HTTPException, Request, Response
+from redis import Redis
+from redis.exceptions import ConnectionError as RedisConnectionError
+from rq import Queue
+from rq.job import JobStatus
+
+from fast_priority.utils import generate_enpoint_list, run_request
+
+load_dotenv()
+
+
+class HighPrioPaths(StrEnum):
+    LISTED = "listed"
+    UNLISTED = "unlisted"
+
+
+logger = logging.getLogger("uvicorn.error")
+# logger.setLevel(logging.DEBUG)
+
+redis_conn = Redis(
+    host=os.environ.get("FAST_PRIORITY_REDIS_HOST", "localhost"),
+    port=int(os.environ.get("FAST_PRIORITY_REDIS_PORT", 6379)),
+    username=os.environ.get("FAST_PRIORITY_REDIS_USER", None),
+    password=os.environ.get("FAST_PRIORITY_REDIS_PASSWORD", None),
+)
+low_queue = Queue("low", connection=redis_conn)
+high_queue = Queue("high", connection=redis_conn)
+
+target_base_url = os.environ["FAST_PRIORITY_TARGET_BASE_URL"]
+priority_mode = HighPrioPaths(
+    os.environ.get("FAST_PRIORITY_HIGH_PRIO_PATHS", "unlisted")
+)
+job_poll_interval = float(os.environ.get("FAST_PRIORITY_POLL_INTERVAL", 1.0))
+job_ttl = int(os.environ.get("FAST_PRIORITY_TTL", 60 * 5))
+
+doc_path = os.environ.get("FAST_PRIORITY_DOC_PATH", "/gateway_docs")
+redoc_path = os.environ.get("FAST_PRIORITY_DOC_PATH", "/gateway_redoc")
+health_path = os.environ.get("FAST_PRIORITY_HEALTH_PATH", "/gateway_health")
+
+prio_paths = None
+prio_base_paths = None
+pass_through_paths = None
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    global prio_paths
+    global prio_base_paths
+    global pass_through_paths
+
+    pass_through_paths = ["health"]
+    pass_through_env = os.environ.get("FAST_PRIORITY_PASS_THROUGH", None)
+    if pass_through_env:
+        pass_through_paths = generate_enpoint_list(pass_through_env)
+
+    prio_paths = generate_enpoint_list(os.environ.get("FAST_PRIORITY_PRIO_PATHS", None))
+    prio_base_paths = generate_enpoint_list(
+        os.environ.get("FAST_PRIORITY_PRIO_BASE_PATHS", None)
+    )
+
+    if not prio_base_paths and not prio_paths:
+        logger.warning("No low priority endpoints defined.")
+    else:
+        if priority_mode == HighPrioPaths.LISTED:
+            logger.info("The following path will be passed to the **HIGH** queue")
+        else:
+            logger.info("The following path will be passed to the **LOW** queue")
+        if prio_paths:
+            logger.info("Low priority path")
+            for path in prio_paths:
+                logger.info(f"    {path}")
+        if prio_base_paths:
+            logger.info("Low priority base path")
+            for path in prio_base_paths:
+                logger.info(f"    {path}")
+
+    if pass_through_paths:
+        logger.info("Pass through paths")
+        for path in pass_through_paths:
+            logger.info(f"    {path}")
+    yield
+
+
+app = FastAPI(
+    lifespan=lifespan,
+    docs_url=doc_path,
+    redoc_url=redoc_path,
+)
+
+
+@app.get(health_path)
+async def heath_check() -> Any:
+    try:
+        async with httpx.AsyncClient() as client:
+            await client.get(f"{target_base_url}")
+    except httpx.ConnectError:
+        target_reachable = False
+    else:
+        target_reachable = True
+
+    try:
+        redis_conn.info()
+    except RedisConnectionError:
+        redis_reachable = False
+    else:
+        redis_reachable = True
+
+    n_jobs_queued_low = None
+    n_jobs_queued_high = None
+    if redis_reachable:
+        n_jobs_queued_high = len(high_queue.jobs)
+        n_jobs_queued_low = len(low_queue.jobs)
+
+    return {
+        "target_reachable": target_reachable,
+        "redis_reachable": redis_reachable,
+        "queue": {"high": n_jobs_queued_high, "low": n_jobs_queued_low},
+    }
+
+
+@app.get("/docs", include_in_schema=False)
+@app.get("/redoc", include_in_schema=False)
+async def get_target_docs(request: Request) -> Any:
+    current_path = request.url.path
+    print(current_path)
+    async with httpx.AsyncClient(timeout=None, follow_redirects=True) as client:
+        response = await client.get(  # type: ignore
+            url=f"{target_base_url}{current_path}",
+        )
+    new_content = response.content.decode("utf-8").replace(
+        "/openapi.json", "/target_openapi.json"
+    )
+    new_bytes = new_content.encode("utf-8")
+    new_headers = dict(response.headers)
+    new_headers["content-length"] = str(len(new_bytes))
+    return Response(
+        content=new_bytes,
+        status_code=response.status_code,
+        headers=new_headers,
+    )
+
+
+@app.get("/target_openapi.json")
+async def get_target_openapi_spec() -> Any:
+    async with httpx.AsyncClient() as client:
+        response = await client.get(f"{target_base_url}/openapi.json")
+    return Response(
+        content=response.content,
+        status_code=response.status_code,
+        headers=dict(response.headers),
+    )
+
+
+async def forward_request(request: Request, path: str) -> Response:
+    assert prio_paths is not None
+    assert prio_base_paths is not None
+    # Prepare request components
+    url = f"/{path}?{request.url.query}"
+    headers = dict(request.headers)
+    headers.pop("host", None)  # Remove original host header
+
+    request_body = await request.body()
+
+    if pass_through_paths and path in pass_through_paths:
+        logger.debug("%s in pass through. Skipping queue", path)
+        async with httpx.AsyncClient(timeout=None, follow_redirects=True) as client:
+            return await client.request(  # type: ignore
+                method=request.method,
+                url=f"{target_base_url}{url}",
+                headers=headers,
+                content=request_body,
+            )
+
+    use_queue = high_queue if priority_mode == HighPrioPaths.UNLISTED else low_queue
+    if path in prio_paths or any(path.startswith(b) for b in prio_base_paths):
+        use_queue = low_queue if priority_mode == HighPrioPaths.UNLISTED else high_queue
+
+    job = use_queue.enqueue(
+        run_request,
+        ttl=job_ttl,
+        failure_ttl=60 * 60,
+        kwargs=dict(
+            method=request.method,
+            url=f"{target_base_url}{url}",
+            headers=headers,
+            content=request_body,
+        ),
+    )
+
+    while job.result is None:
+        status = job.get_status(refresh=True)
+        if status in [JobStatus.FAILED, JobStatus.STOPPED, JobStatus.CANCELED]:
+            raise HTTPException(status_code=500, detail="Could not run request")
+        logger.debug(
+            "Waiting. Current status: %s of %s", job.get_status(refresh=True), job.id
+        )
+        await asyncio.sleep(job_poll_interval)
+
+    return job.result
+
+
+@app.api_route("/{path:path}", methods=["GET", "POST"], include_in_schema=False)
+async def proxy_request(request: Request, path: str) -> Any:
+    response = await forward_request(request, path)
+    print(response)
+    return Response(
+        content=response.content,
+        status_code=response.status_code,
+        headers=response.headers,
+    )

fast_priority-0.0.14/fast_priority/cli.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+import os
+import sys
+from urllib.parse import quote
+
+import uvicorn
+
+
+def urlencode(s: str) -> str:
+    safe = "-_.~"
+    return quote(s, safe=safe)
+
+
+def main():
+    role = "worker" if os.getenv("FAST_PRIORITY_WORKERS") else "api"
+
+    print("======================================")
+    print("==> Fast Priority Queue RUN SCRIPT <==")
+    print("======================================")
+    print(f"--> MODE: {role}")
+    print("======================================")
+
+    if role == "api":
+        from fast_priority.app import app
+
+        uvicorn.run(
+            app,
+            host=os.getenv("FAST_PRIORITY_HOST", "0.0.0.0"),
+            port=int(os.getenv("FAST_PRIORITY_PORT", 8000)),
+            # log_level="debug",
+            reload=False,  # Disabled for production
+        )
+    elif role == "worker":
+        from rq.cli.cli import main as rq_cli
+
+        print("Running queue worker")
+        workers = os.getenv("FAST_PRIORITY_WORKERS", "1")
+        print(f"Using {workers} workers")
+
+        redis_host = os.getenv("FAST_PRIORITY_REDIS_HOST", "localhost")
+        redis_user = os.getenv("FAST_PRIORITY_REDIS_USER", "")
+        redis_password = os.getenv("FAST_PRIORITY_REDIS_PASSWORD", "")
+        redis_port = os.getenv("FAST_PRIORITY_REDIS_PORT", "")
+
+        auth = ""
+        if redis_user and redis_password:
+            auth = f"{urlencode(redis_user)}:{urlencode(redis_password)}@"
+        elif redis_password:
+            auth = f":{urlencode(redis_password)}@"
+
+        uri = f"redis://{auth}{redis_host}"
+        if redis_port:
+            uri += f":{redis_port}"
+
+        print(f"  Using redis uri: {uri}")
+
+        try:
+            worker_count = int(workers)
+            if worker_count < 1:
+                raise ValueError
+        except ValueError:
+            print("ERR:: Invalid value for worker")
+            sys.exit(1)
+
+        if worker_count == 1:
+            print("Running with one worker")
+            rq_cli(["worker", "high", "low", "--url", uri], standalone_mode=True)
+
+        else:
+            print("Running multiple workers")
+            rq_cli(
+                [
+                    "worker-pool",
+                    "high",
+                    "low",
+                    "-n",
+                    str(worker_count),
+                    "--url",
+                    uri,
+                ],
+                standalone_mode=True,
+            )
+
+    else:
+        print("ERR:: Invalid run mode")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    import dotenv
+
+    dotenv.load_dotenv()
+    main()

fast_priority-0.0.14/fast_priority/utils.py

@@ -0,0 +1,17 @@
+import httpx
+
+
+def generate_enpoint_list(raw_endpoint_str: str | None) -> list[str]:
+    ret = []
+    if raw_endpoint_str:
+        ret = [
+            p.strip() for p in raw_endpoint_str.strip().split(",") if p not in {"", " "}
+        ]
+
+    return ret
+
+
+def run_request(method: str, url: str, headers: dict, content: dict):
+    # print(f"Got: {method=}, {url=}")
+    with httpx.Client(timeout=None, follow_redirects=True) as client:
+        return client.request(method=method, url=url, headers=headers, content=content)

fast_priority-0.0.14/pyproject.toml

@@ -0,0 +1,93 @@
+[build-system]
+requires = ["flit_core >=3.2,<4"]
+build-backend = "flit_core.buildapi"
+
+[project]
+name = "fast-priority"
+authors = [
+  { name = "Korbinian Schweiger", email = "korbinian.schweiger@gmail.com" },
+]
+license = { file = "LICENSE" }
+version = "0.0.14"
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3.12",
+  "Framework :: FastAPI",
+  "Intended Audience :: System Administrators",
+  "Topic :: Internet",
+]
+keywords = ["queue", "fastapi", "priority", "redis"]
+description = "Simple and streigt forward priority queing gateway using fastapi"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+  "fastapi[standard]>=0.115.8",
+  "httpx",
+  "python-dotenv>=1.0.1",
+  "rq>=2.1.0",
+  "click",
+  "uvicorn>=0.34.0"
+]
+
+[project.scripts]
+run-fast-priority = "fast_priority.cli:main"
+
+[tool.uv]
+default-groups = ["dev", "test"]
+
+[dependency-groups]
+test = [
+  "pytest",
+  "pytest-mock",
+  "pytest-cov"
+]
+dev = [
+  "uv",
+  "ruff",
+  "pre-commit",
+  "bpython",
+  "debugpy",
+  "flit>=3.11.0",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests/unit/"]
+
+[tool.ruff]
+line-length = 88
+target-version = "py312"
+
+[tool.ruff.lint]
+select = [
+  "E",
+  "F",
+  "I",
+  "PD",
+  "PT",
+  "NPY",
+  "N",
+  "W",
+  "RET",
+  "ANN",
+  "RUF",
+  "SIM",
+  "PERF",
+]
+unfixable = ["F841", "RUF015"]
+ignore = [
+  "ANN202",
+  "ANN205",
+  "ANN001",
+  "ANN002",
+  "ANN003",
+  "ANN401",
+  "RET502",
+  "RET503",
+  "RET504",
+  "RET505",
+  "RUF005",
+  "RUF009",
+  "E731",
+]