fluidattacks_core_http 12.1.0__tar.gz → 12.2.0__tar.gz

{fluidattacks_core_http-12.1.0 → fluidattacks_core_http-12.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: fluidattacks_core_http
-Version: 12.1.0
+Version: 12.2.0
 Summary: Fluid Attacks Core HTTP Library
 Author-email: Development <development@fluidattacks.com>
 License: MPL-2.0

fluidattacks_core_http-12.2.0/fluidattacks_core/http/__init__.py

@@ -0,0 +1,7 @@
+from .client import (
+    MAX_RESPONSE_BYTES,
+    ResponseTooLargeError,
+    request,
+)
+
+__all__ = ["MAX_RESPONSE_BYTES", "ResponseTooLargeError", "request"]

{fluidattacks_core_http-12.1.0 → fluidattacks_core_http-12.2.0}/fluidattacks_core/http/client.py

@@ -1,6 +1,7 @@
 import ipaddress
 import ssl
 from collections.abc import Sequence
+from contextvars import ContextVar
 from typing import (
     Any,
     Literal,
@@ -17,6 +18,51 @@ from .validations import (
 
 _MAX_REDIRECTS = 10
 _METHODS_SWITCH_TO_GET = frozenset({301, 302, 303})
+_READ_CHUNK_BYTES = 64 * 1024
+
+# Bounds each response so that no single request can exhaust the pod.
+MAX_RESPONSE_BYTES = 64 * 1024 * 1024
+
+# aiohttp builds the response object, so the caller's cap cannot be passed to
+# it directly.
+_CAP: ContextVar[int] = ContextVar("max_response_bytes", default=MAX_RESPONSE_BYTES)
+
+
+class ResponseTooLargeError(aiohttp.ClientPayloadError):
+    pass
+
+
+class BoundedResponse(aiohttp.ClientResponse):
+    async def read(self) -> bytes:
+        if self._body is None:
+            max_response_bytes = _CAP.get()
+            try:
+                self._reject_oversized_content_length(max_response_bytes)
+                self._body = await self._accumulate_capped(max_response_bytes)
+            except BaseException:
+                self.close()
+                raise
+        # Deferring to the parent awaits the request writer through internals
+        # a subclass cannot name.
+        return await super().read()
+
+    def _reject_oversized_content_length(self, max_response_bytes: int) -> None:
+        declared = self.content_length
+        if declared is not None and declared > max_response_bytes:
+            msg = f"Response declares {declared} bytes, over the {max_response_bytes} limit"
+            raise ResponseTooLargeError(msg)
+
+    async def _accumulate_capped(self, max_response_bytes: int) -> bytes:
+        # Counting decoded bytes as they arrive is the only bound that
+        # survives a compressed or chunked body, where the declared length
+        # says nothing about what decoding produces.
+        body = bytearray()
+        async for chunk in self.content.iter_chunked(_READ_CHUNK_BYTES):
+            body.extend(chunk)
+            if len(body) > max_response_bytes:
+                msg = f"Response exceeds the {max_response_bytes} byte limit"
+                raise ResponseTooLargeError(msg)
+        return bytes(body)
 
 
 def get_secure_connector(
@@ -55,6 +101,7 @@ async def request(  # noqa: PLR0913
     enforce_sanitization: bool = False,
     headers: dict[str, str] | None = None,
     json: Any | None = None,  # noqa: ANN401
+    max_response_bytes: int = MAX_RESPONSE_BYTES,
     ports: list[int] | None = None,
     schemes: list[str] | None = None,
     timeout: int = 10,  # noqa: ASYNC109
@@ -77,6 +124,7 @@ async def request(  # noqa: PLR0913
     connection = connector(
         ssl=ssl.create_default_context(cafile=certifi.where()),
     )
+    _CAP.set(max_response_bytes)
     if allow_redirects is True:
         return await _request_with_validated_redirects(
             connection=connection,
@@ -98,6 +146,7 @@ async def request(  # noqa: PLR0913
         aiohttp.ClientSession(
             connector=connection,
             headers=headers,
+            response_class=BoundedResponse,
         ) as session,
         session.request(
             method,
@@ -130,7 +179,11 @@ async def _request_with_validated_redirects(  # noqa: PLR0913
     current_url = initial_url
     current_method: Literal["GET", "POST", "PUT", "PATCH", "DELETE"] = initial_method
     current_json: Any = json
-    async with aiohttp.ClientSession(connector=connection, headers=headers) as session:
+    async with aiohttp.ClientSession(
+        connector=connection,
+        headers=headers,
+        response_class=BoundedResponse,
+    ) as session:
         for _ in range(_MAX_REDIRECTS + 1):
             async with session.request(
                 current_method,

{fluidattacks_core_http-12.1.0 → fluidattacks_core_http-12.2.0}/fluidattacks_core/http/validations.py

@@ -10,7 +10,7 @@ class HTTPValidationError(Exception):
 
 
 def validate_scheme(scheme: str | None, schemes: list[str]) -> None:
-    if scheme and scheme not in schemes:
+    if scheme not in schemes:
         msg = f"Only allowed schemes are {', '.join(schemes)}"
         raise HTTPValidationError(msg)
 

{fluidattacks_core_http-12.1.0 → fluidattacks_core_http-12.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fluidattacks_core_http"
-version = "12.1.0"
+version = "12.2.0"
 description = "Fluid Attacks Core HTTP Library"
 authors = [{ name = "Development", email = "development@fluidattacks.com" }]
 license = { text = "MPL-2.0" }

{fluidattacks_core_http-12.1.0 → fluidattacks_core_http-12.2.0}/tests/test_client.py

@@ -1,5 +1,7 @@
 """Tests for fluidattacks_core.http.client.request."""
 
+import asyncio
+import gzip
 from collections.abc import Awaitable, Callable
 
 import aiohttp
@@ -7,10 +9,12 @@ import pytest
 from aiohttp import web
 from aiohttp.test_utils import TestServer
 
-from fluidattacks_core.http import request
-from fluidattacks_core.http.validations import HTTPValidationError
+from fluidattacks_core.http import ResponseTooLargeError, request
+from fluidattacks_core.http.validations import HTTPValidationError, validate_url
 
 RouteHandler = Callable[[web.Request], Awaitable[web.StreamResponse]]
+_CAP = 64 * 1024
+_MAX_HOPS = 11
 
 
 async def _build_server(routes: dict[str, RouteHandler]) -> TestServer:
@@ -237,3 +241,219 @@ async def test_exceeding_max_redirects_raises_too_many_redirects() -> None:
             )
     finally:
         await server.close()
+
+
+def _gzip_bomb(decompressed_bytes: int) -> bytes:
+    return gzip.compress(b"\x00" * decompressed_bytes, compresslevel=9)
+
+
+async def _build_body_server(body: bytes, headers: dict[str, str]) -> TestServer:
+    async def handler(_req: web.Request) -> web.Response:
+        return web.Response(body=body, headers=headers)
+
+    return await _build_server({"/body": handler})
+
+
+async def _capped_request(
+    url: str,
+    *,
+    max_response_bytes: int,
+    allow_redirects: bool | None = None,
+) -> aiohttp.ClientResponse:
+    return await request(
+        url,
+        method="GET",
+        allow_local_network=True,
+        allow_localhost=True,
+        allow_redirects=allow_redirects,
+        dns_rebind_protection=False,
+        max_response_bytes=max_response_bytes,
+    )
+
+
+@pytest.mark.asyncio
+async def test_compressed_body_over_cap_is_rejected() -> None:
+    bomb = _gzip_bomb(8 * 1024 * 1024)
+    server = await _build_body_server(
+        bomb,
+        {"Content-Encoding": "gzip", "Content-Type": "application/json"},
+    )
+    try:
+        assert len(bomb) < 1024 * 1024
+        with pytest.raises(ResponseTooLargeError):
+            await _capped_request(
+                _make_server_url(server, "/body"),
+                max_response_bytes=1024 * 1024,
+            )
+    finally:
+        await server.close()
+
+
+@pytest.mark.asyncio
+async def test_body_within_cap_is_still_returned() -> None:
+    server = await _build_body_server(b"payload", {})
+    try:
+        response = await _capped_request(
+            _make_server_url(server, "/body"),
+            max_response_bytes=1024 * 1024,
+        )
+        assert await response.text() == "payload"
+    finally:
+        await server.close()
+
+
+@pytest.mark.asyncio
+async def test_cap_rejects_an_oversized_body_after_a_redirect() -> None:
+    bomb = _gzip_bomb(8 * 1024 * 1024)
+
+    async def handle_start(_req: web.Request) -> web.Response:
+        return web.Response(status=302, headers={"Location": "/final"})
+
+    async def handle_final(_req: web.Request) -> web.Response:
+        return web.Response(
+            body=bomb,
+            headers={"Content-Encoding": "gzip", "Content-Type": "application/json"},
+        )
+
+    server = await _build_server({"/start": handle_start, "/final": handle_final})
+    try:
+        with pytest.raises(ResponseTooLargeError):
+            await _capped_request(
+                _make_server_url(server, "/start"),
+                max_response_bytes=1024 * 1024,
+                allow_redirects=True,
+            )
+    finally:
+        await server.close()
+
+
+@pytest.mark.asyncio
+async def test_declared_length_over_cap_is_rejected() -> None:
+    server = await _build_body_server(b"a" * (2 * 1024 * 1024), {})
+    try:
+        with pytest.raises(ResponseTooLargeError, match="declares"):
+            await _capped_request(
+                _make_server_url(server, "/body"),
+                max_response_bytes=1024 * 1024,
+            )
+    finally:
+        await server.close()
+
+
+@pytest.mark.parametrize(
+    "url",
+    [
+        "//evil.example/jwks",
+        "//evil.example:8080/jwks",
+        "evil.example/jwks",
+        "evil.example:8080/jwks",
+    ],
+)
+def test_schemeless_url_is_rejected_when_schemes_are_restricted(url: str) -> None:
+    with pytest.raises(HTTPValidationError):
+        validate_url(
+            url,
+            ascii_only=False,
+            enforce_sanitization=False,
+            ports=[],
+            schemes=["https"],
+        )
+
+
+def test_allowed_scheme_still_passes() -> None:
+    validate_url(
+        "https://good.example/jwks",
+        ascii_only=False,
+        enforce_sanitization=False,
+        ports=[],
+        schemes=["https"],
+    )
+
+
+@pytest.mark.asyncio
+async def test_relative_redirect_keeps_the_scheme_of_its_base() -> None:
+    async def handle_start(_req: web.Request) -> web.Response:
+        return web.Response(status=302, headers={"Location": "/final"})
+
+    async def handle_final(_req: web.Request) -> web.Response:
+        return web.Response(status=200, text="ok")
+
+    server = await _build_server({"/start": handle_start, "/final": handle_final})
+    try:
+        response = await _permissive_request(
+            _make_server_url(server, "/start"),
+            allow_redirects=True,
+            schemes=["http"],
+        )
+        assert response.status == 200
+        assert await response.text() == "ok"
+    finally:
+        await server.close()
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("compressed", [False, True])
+async def test_cap_admits_a_body_of_exactly_the_limit(compressed: bool) -> None:
+    body = _gzip_bomb(_CAP) if compressed else b"a" * _CAP
+    headers = {"Content-Encoding": "gzip"} if compressed else {}
+    server = await _build_body_server(body, headers)
+    try:
+        response = await _capped_request(
+            _make_server_url(server, "/body"), max_response_bytes=_CAP
+        )
+        assert len(await response.text()) == _CAP
+    finally:
+        await server.close()
+
+
+@pytest.mark.asyncio
+async def test_cap_bounds_each_hop_rather_than_the_whole_chain() -> None:
+    # The accepted multiplier: every hop may serve just under the cap, so a
+    # full chain moves _MAX_HOPS times the limit and still succeeds.
+    body = b"a" * (_CAP - 1)
+
+    async def handle_hop(req: web.Request) -> web.Response:
+        hop = int(req.query.get("n", "0"))
+        if hop >= _MAX_HOPS - 1:
+            return web.Response(body=body)
+        return web.Response(
+            status=302, body=body, headers={"Location": f"/hop?n={hop + 1}"}
+        )
+
+    server = await _build_server({"/hop": handle_hop})
+    try:
+        response = await _capped_request(
+            _make_server_url(server, "/hop?n=0"),
+            max_response_bytes=_CAP,
+            allow_redirects=True,
+        )
+        assert response.status == 200
+        assert len(await response.text()) == _CAP - 1
+    finally:
+        await server.close()
+
+def test_response_too_large_stays_catchable_as_a_client_error() -> None:
+    # Callers degrade gracefully on transport failures; narrowing this base
+    # converts their soft fallbacks into client-facing errors, and in one
+    # fire-and-forget path drops the log entirely.
+    assert issubclass(ResponseTooLargeError, aiohttp.ClientError)
+
+
+@pytest.mark.asyncio
+async def test_concurrent_requests_do_not_share_a_cap() -> None:
+    # The cap reaches the response through context, so overlapping requests
+    # must not observe each other's limit.
+    server = await _build_body_server(
+        _gzip_bomb(4 * 1024 * 1024), {"Content-Encoding": "gzip"}
+    )
+    url = _make_server_url(server, "/body")
+    try:
+        tight, generous = await asyncio.gather(
+            _capped_request(url, max_response_bytes=1024 * 1024),
+            _capped_request(url, max_response_bytes=32 * 1024 * 1024),
+            return_exceptions=True,
+        )
+        assert isinstance(tight, ResponseTooLargeError)
+        assert not isinstance(generous, BaseException)
+        assert len(await generous.text()) == 4 * 1024 * 1024
+    finally:
+        await server.close()

{fluidattacks_core_http-12.1.0 → fluidattacks_core_http-12.2.0}/uv.lock

@@ -217,7 +217,7 @@ wheels = [
 
 [[package]]
 name = "fluidattacks-core-http"
-version = "12.1.0"
+version = "12.2.0"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },

fluidattacks_core_http-12.1.0/build/default.nix

@@ -1,19 +0,0 @@
-{ src, workspace_root }:
-{
-  inherit src workspace_root;
-  root_path = "develops/fluidattacks-core/python/http";
-  module_name = "fluidattacks_core";
-  pypi_token = {
-    method = "oidc";
-  };
-  override = {
-    checks = {
-      basedpyright = false;
-    };
-    configs = {
-      import_linter = ../import-linter.cfg;
-      mypy = ../mypy.ini;
-      ruff = ../ruff.toml;
-    };
-  };
-}

fluidattacks_core_http-12.1.0/build/filter.nix

@@ -1,13 +0,0 @@
-path_filter: src:
-path_filter {
-  root = src;
-  include = [
-    "fluidattacks_core"
-    "tests"
-    "import-linter.cfg"
-    "mypy.ini"
-    "pyproject.toml"
-    "ruff.toml"
-    "uv.lock"
-  ];
-}

fluidattacks_core_http-12.1.0/flake.lock

@@ -1,303 +0,0 @@
-{
-  "nodes": {
-    "flake-parts": {
-      "inputs": {
-        "nixpkgs-lib": "nixpkgs-lib"
-      },
-      "locked": {
-        "lastModified": 1762810396,
-        "narHash": "sha256-dxFVgQPG+R72dkhXTtqUm7KpxElw3u6E+YlQ2WaDgt8=",
-        "owner": "hercules-ci",
-        "repo": "flake-parts",
-        "rev": "0bdadb1b265fb4143a75bd1ec7d8c915898a9923",
-        "type": "github"
-      },
-      "original": {
-        "owner": "hercules-ci",
-        "repo": "flake-parts",
-        "type": "github"
-      }
-    },
-    "nix_filter": {
-      "locked": {
-        "lastModified": 1757882181,
-        "narHash": "sha256-+cCxYIh2UNalTz364p+QYmWHs0P+6wDhiWR4jDIKQIU=",
-        "owner": "numtide",
-        "repo": "nix-filter",
-        "rev": "59c44d1909c72441144b93cf0f054be7fe764de5",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "nix-filter",
-        "type": "github"
-      }
-    },
-    "nixpkgs": {
-      "locked": {
-        "lastModified": 1758690382,
-        "narHash": "sha256-NY3kSorgqE5LMm1LqNwGne3ZLMF2/ILgLpFr1fS4X3o=",
-        "owner": "nixos",
-        "repo": "nixpkgs",
-        "rev": "e643668fd71b949c53f8626614b21ff71a07379d",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nixos",
-        "ref": "nixos-unstable",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "nixpkgs-lib": {
-      "locked": {
-        "lastModified": 1761765539,
-        "narHash": "sha256-b0yj6kfvO8ApcSE+QmA6mUfu8IYG6/uU28OFn4PaC8M=",
-        "owner": "nix-community",
-        "repo": "nixpkgs.lib",
-        "rev": "719359f4562934ae99f5443f20aa06c2ffff91fc",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-community",
-        "repo": "nixpkgs.lib",
-        "type": "github"
-      }
-    },
-    "nixpkgs_2": {
-      "locked": {
-        "lastModified": 1758690382,
-        "narHash": "sha256-NY3kSorgqE5LMm1LqNwGne3ZLMF2/ILgLpFr1fS4X3o=",
-        "owner": "nixos",
-        "repo": "nixpkgs",
-        "rev": "e643668fd71b949c53f8626614b21ff71a07379d",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nixos",
-        "ref": "nixos-unstable",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "nixpkgs_3": {
-      "locked": {
-        "lastModified": 1761373498,
-        "narHash": "sha256-Q/uhWNvd7V7k1H1ZPMy/vkx3F8C13ZcdrKjO7Jv7v0c=",
-        "owner": "nixos",
-        "repo": "nixpkgs",
-        "rev": "6a08e6bb4e46ff7fcbb53d409b253f6bad8a28ce",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nixos",
-        "ref": "nixos-unstable",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "nixpkgs_flake": {
-      "locked": {
-        "lastModified": 1778253243,
-        "narHash": "sha256-KkH2QvU6iRLDTGGEwH5jnMqHWj4zMTuHxi1S1zdr01w=",
-        "owner": "nixos",
-        "repo": "nixpkgs",
-        "rev": "4fcda7103530b23c5ca44286344912082aad4220",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nixos",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "pyproject-build-systems": {
-      "inputs": {
-        "nixpkgs": "nixpkgs",
-        "pyproject-nix": "pyproject-nix",
-        "uv2nix": "uv2nix"
-      },
-      "locked": {
-        "lastModified": 1761781027,
-        "narHash": "sha256-YDvxPAm2WnxrznRqWwHLjryBGG5Ey1ATEJXrON+TWt8=",
-        "owner": "pyproject-nix",
-        "repo": "build-system-pkgs",
-        "rev": "795a980d25301e5133eca37adae37283ec3c8e66",
-        "type": "github"
-      },
-      "original": {
-        "owner": "pyproject-nix",
-        "repo": "build-system-pkgs",
-        "type": "github"
-      }
-    },
-    "pyproject-nix": {
-      "inputs": {
-        "nixpkgs": [
-          "python_builder",
-          "pyproject-build-systems",
-          "nixpkgs"
-        ]
-      },
-      "locked": {
-        "lastModified": 1758265079,
-        "narHash": "sha256-amLaLNwKSZPShQHzfgmc/9o76dU8xzN0743dWgvYlr8=",
-        "owner": "nix-community",
-        "repo": "pyproject.nix",
-        "rev": "02e9418fd4af638447dca4b17b1280da95527fc9",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-community",
-        "repo": "pyproject.nix",
-        "type": "github"
-      }
-    },
-    "pyproject-nix_2": {
-      "inputs": {
-        "nixpkgs": "nixpkgs_2"
-      },
-      "locked": {
-        "lastModified": 1762427963,
-        "narHash": "sha256-CkPlAbIQ87wmjy5qHibfzk4DmMGBNqFer+lLfXjpP5M=",
-        "owner": "pyproject-nix",
-        "repo": "pyproject.nix",
-        "rev": "4540ea004e04fcd12dd2738d51383d10f956f7b9",
-        "type": "github"
-      },
-      "original": {
-        "owner": "pyproject-nix",
-        "repo": "pyproject.nix",
-        "type": "github"
-      }
-    },
-    "pyproject-nix_3": {
-      "inputs": {
-        "nixpkgs": [
-          "python_builder",
-          "uv2nix",
-          "nixpkgs"
-        ]
-      },
-      "locked": {
-        "lastModified": 1760402624,
-        "narHash": "sha256-jF6UKLs2uGc2rtved8Vrt58oTWjTQoAssuYs/0578Z4=",
-        "owner": "pyproject-nix",
-        "repo": "pyproject.nix",
-        "rev": "84c4ea102127c77058ea1ed7be7300261fafc7d2",
-        "type": "github"
-      },
-      "original": {
-        "owner": "pyproject-nix",
-        "repo": "pyproject.nix",
-        "type": "github"
-      }
-    },
-    "python_builder": {
-      "inputs": {
-        "nix_filter": "nix_filter",
-        "nixpkgs_flake": "nixpkgs_flake",
-        "pyproject-build-systems": "pyproject-build-systems",
-        "pyproject-nix": "pyproject-nix_2",
-        "shell-helpers": "shell-helpers",
-        "uv2nix": "uv2nix_2"
-      },
-      "locked": {
-        "dir": "common/utils/python-builder",
-        "lastModified": 1787078362,
-        "narHash": "sha256-HYL7Rn6SuNjYxkt/PwFLksZjsauCiY+ENbOWryLsIlw=",
-        "ref": "refs/heads/trunk",
-        "rev": "09fd25a13309eb5e3b5b2a061bb340df3ae5d281",
-        "shallow": true,
-        "type": "git",
-        "url": "ssh://git@gitlab.com/fluidattacks/universe"
-      },
-      "original": {
-        "dir": "common/utils/python-builder",
-        "rev": "09fd25a13309eb5e3b5b2a061bb340df3ae5d281",
-        "shallow": true,
-        "type": "git",
-        "url": "ssh://git@gitlab.com/fluidattacks/universe"
-      }
-    },
-    "root": {
-      "inputs": {
-        "python_builder": "python_builder"
-      }
-    },
-    "shell-helpers": {
-      "inputs": {
-        "flake-parts": "flake-parts",
-        "nixpkgs": [
-          "python_builder",
-          "nixpkgs_flake"
-        ]
-      },
-      "locked": {
-        "dir": "common/utils/shell-helpers",
-        "lastModified": 1762806066,
-        "narHash": "sha256-Wz99Fl7SpPU1NkTHJ36XOo6DjOEAMXCw3ThRABOS2Hs=",
-        "ref": "refs/heads/trunk",
-        "rev": "d73cfdc7ae9e7f547e22a4481d4c2ccce38b26a8",
-        "shallow": true,
-        "type": "git",
-        "url": "ssh://git@gitlab.com/fluidattacks/universe"
-      },
-      "original": {
-        "dir": "common/utils/shell-helpers",
-        "rev": "d73cfdc7ae9e7f547e22a4481d4c2ccce38b26a8",
-        "shallow": true,
-        "type": "git",
-        "url": "ssh://git@gitlab.com/fluidattacks/universe"
-      }
-    },
-    "uv2nix": {
-      "inputs": {
-        "nixpkgs": [
-          "python_builder",
-          "pyproject-build-systems",
-          "nixpkgs"
-        ],
-        "pyproject-nix": [
-          "python_builder",
-          "pyproject-build-systems",
-          "pyproject-nix"
-        ]
-      },
-      "locked": {
-        "lastModified": 1758933732,
-        "narHash": "sha256-HAmm1GBS1myZCFuog0DC2ZLaynvZtiUI2Crmo+cdQI0=",
-        "owner": "pyproject-nix",
-        "repo": "uv2nix",
-        "rev": "273ce18f913d8559e0d04f820d724308966d7c4d",
-        "type": "github"
-      },
-      "original": {
-        "owner": "pyproject-nix",
-        "repo": "uv2nix",
-        "type": "github"
-      }
-    },
-    "uv2nix_2": {
-      "inputs": {
-        "nixpkgs": "nixpkgs_3",
-        "pyproject-nix": "pyproject-nix_3"
-      },
-      "locked": {
-        "lastModified": 1761872265,
-        "narHash": "sha256-i25GRgp2vUOebY70L3NTAgkd+Pr1hnn5xM3qHxH0ONU=",
-        "owner": "pyproject-nix",
-        "repo": "uv2nix",
-        "rev": "74dfb62871be152ad3673b143b0cc56105a4f3c5",
-        "type": "github"
-      },
-      "original": {
-        "owner": "pyproject-nix",
-        "repo": "uv2nix",
-        "type": "github"
-      }
-    }
-  },
-  "root": "root",
-  "version": 7
-}

fluidattacks_core_http-12.1.0/flake.nix

@@ -1,29 +0,0 @@
-{
-  description = "Fluid Attacks Core http package.";
-
-  inputs = {
-    python_builder = {
-      url = "git+ssh://git@gitlab.com/fluidattacks/universe?shallow=1&rev=09fd25a13309eb5e3b5b2a061bb340df3ae5d281&dir=common/utils/python-builder";
-    };
-  };
-
-  outputs =
-    { self, ... }@inputs:
-    let
-      build_args =
-        {
-          system,
-          python_version,
-          nixpkgs,
-          builders,
-          scripts,
-        }:
-        import ./build {
-          src = import ./build/filter.nix nixpkgs.nix-filter self;
-          workspace_root = ./.;
-        };
-    in
-    {
-      packages = inputs.python_builder.outputs.build build_args;
-    };
-}

fluidattacks_core_http-12.1.0/fluidattacks_core/http/__init__.py

@@ -1,5 +0,0 @@
-from .client import (
-    request,
-)
-
-__all__ = ["request"]