fluidattacks_core_logging 12.0.0__tar.gz → 12.2.0__tar.gz

fluidattacks_core_logging-12.2.0/.envrc

@@ -0,0 +1 @@
+use flake ../../..#fluidattacks-core-logging

fluidattacks_core_logging-12.2.0/.gitignore

@@ -0,0 +1,15 @@
+dist/
+dist-*/
+*.zip
+/utils/terraform-modules/**/.terraform.lock.hcl
+/.cargo-cache
+target/
+.direnv/
+.venv/
+.vscode/settings.json
+.zed/settings.json
+# each package's shell writes its own, beside the package rather than here
+**/.vscode/settings.json
+*.so
+# the publish check builds into its own tree per architecture
+target-*/

{fluidattacks_core_logging-12.0.0 → fluidattacks_core_logging-12.2.0}/PKG-INFO

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

{fluidattacks_core_logging-12.0.0 → fluidattacks_core_logging-12.2.0}/fluidattacks_core/logging/__init__.py

@@ -5,6 +5,7 @@ import logging.config
 import sys
 from typing import TYPE_CHECKING
 
+from fluidattacks_core.logging.capture import CapturedLog, CaptureHandler
 from fluidattacks_core.logging.presets import DATE_FORMAT, PRODUCT_LOGGING
 from fluidattacks_core.logging.sources.utils import (
     set_commit_ref_name,
@@ -45,10 +46,24 @@ def init_logging(preset: _DictConfigArgs | None = None) -> None:
     init_uncaught_exception_logging()
 
 
+def init_logging_captured(preset: _DictConfigArgs | None = None) -> CapturedLog:
+    """`init_logging`, that also keeps a copy of everything logged.
+
+    The console is unchanged; the copy is what a program reads back to hand its output to
+    someone else once the run is over. Call it once: each call adds another copy.
+    """
+    init_logging(preset)
+    capture = CapturedLog()
+    logging.getLogger().addHandler(CaptureHandler(capture))
+    return capture
+
+
 __all__ = [
     "DATE_FORMAT",
     "PRODUCT_LOGGING",
+    "CapturedLog",
     "init_logging",
+    "init_logging_captured",
     "init_uncaught_exception_logging",
     "set_commit_ref_name",
     "set_commit_sha",

fluidattacks_core_logging-12.2.0/fluidattacks_core/logging/capture.py

@@ -0,0 +1,57 @@
+"""Opt-in copy of what the logger writes.
+
+For a program that has to hand its output to someone else after the run.
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+
+from fluidattacks_core.logging.presets import DATE_FORMAT
+
+
+class CapturedLog:
+    """What the logger wrote since `init_logging_captured`, as plain text lines.
+
+    Each line reads `<date> [<level>] [<logger>] <message>`, followed by the traceback
+    when the record carries one. It is the same whatever the environment, so it holds no
+    ANSI colors and no JSON, unlike the console.
+
+    It keeps everything: it never trims, and whoever receives it decides how much to
+    accept. Safe to read while other threads log.
+    """
+
+    def __init__(self) -> None:
+        self._lock = threading.Lock()
+        self._lines: list[str] = []
+
+    def _push(self, text: str) -> None:
+        with self._lock:
+            self._lines.append(text)
+
+    def contents(self) -> str:
+        """Return the output so far."""
+        with self._lock:
+            return "".join(self._lines)
+
+
+class CaptureHandler(logging.Handler):
+    """Feeds every record it receives into a `CapturedLog`."""
+
+    def __init__(self, capture: CapturedLog) -> None:
+        super().__init__()
+        self.capture = capture
+        self.setFormatter(
+            logging.Formatter(
+                "{asctime} [{levelname}] [{name}] {message}",
+                datefmt=DATE_FORMAT,
+                style="{",
+            ),
+        )
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            self.capture._push(self.format(record) + "\n")  # noqa: SLF001
+        except Exception:  # noqa: BLE001
+            self.handleError(record)

{fluidattacks_core_logging-12.0.0 → fluidattacks_core_logging-12.2.0}/fluidattacks_core/logging/handlers.py

@@ -1,9 +1,10 @@
 import copy
 import logging
 import sys
+import threading
 from logging.handlers import HTTPHandler, QueueHandler, QueueListener
-from queue import Queue
-from typing import TextIO
+from queue import Full, Queue
+from typing import TextIO, cast
 
 import simplejson as json
 
@@ -81,23 +82,46 @@ class ProductionSyncHandler(logging.StreamHandler[TextIO]):
         self.setFormatter(CustomJsonFormatter())
 
 
+class _DrainingStopListener(QueueListener):
+    """Listener that drains the queue before stopping, so a full one cannot reject it."""
+
+    def stop(self) -> None:
+        cast("Queue[object]", self.queue).join()
+        super().stop()
+
+
 class ProductionAsyncHandler(CustomQueueHandler):
     """Logging handler for production environments implemented with `QueueHandler`.
 
     Includes:
     - Filters: `NoBatchFilter`, `ProductionOnlyFilter`
     - Formatter: `CustomJsonFormatter`
+
+    A positive `max_queue_size` drops records once the queue is full.
     """
 
-    def __init__(self, stream: TextIO = sys.stderr) -> None:
+    def __init__(self, stream: TextIO = sys.stderr, max_queue_size: int = 0) -> None:
         handler = logging.StreamHandler(stream)
         handler.addFilter(ProductionOnlyFilter())
         handler.setFormatter(CustomJsonFormatter())
 
-        super().__init__(Queue())
+        super().__init__(Queue(maxsize=max_queue_size))
         self.shutting_down = False
+        self.dropped = 0
+        self._dropped_lock = threading.Lock()
 
-        self._attach_listener(QueueListener(self.queue, handler))
+        self._attach_listener(_DrainingStopListener(self.queue, handler))
+
+    def on_drop(self) -> None:
+        """Report a dropped record; it must neither log nor raise."""
+
+    def enqueue(self, record: logging.LogRecord) -> None:
+        try:
+            super().enqueue(record)
+        except Full:
+            with self._dropped_lock:
+                self.dropped += 1
+            self.on_drop()
 
     def emit(self, record: logging.LogRecord) -> None:
         if self.shutting_down:

{fluidattacks_core_logging-12.0.0 → fluidattacks_core_logging-12.2.0}/import-linter.cfg

@@ -1,16 +1,7 @@
 [importlinter]
-  root_package = fluidattacks_core
+  root_package = fluidattacks_core.logging
   include_external_packages = True
 
-[importlinter:contract:portion]
-  name = Single Portion
-  type = layers
-  containers =
-    fluidattacks_core
-  exhaustive = true
-  layers =
-    logging
-
 [importlinter:contract:dag]
   name = Direct Acyclic Graph
   type = layers
@@ -18,6 +9,7 @@
     fluidattacks_core.logging
   exhaustive = true
   layers =
+    capture
     presets
     handlers
     formatters

{fluidattacks_core_logging-12.0.0 → fluidattacks_core_logging-12.2.0}/pyproject.toml

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

fluidattacks_core_logging-12.2.0/tests/test_capture.py

@@ -0,0 +1,69 @@
+import logging
+from collections.abc import Iterator
+
+import pytest
+
+from fluidattacks_core.logging import CapturedLog, init_logging_captured
+from fluidattacks_core.logging.capture import CaptureHandler
+
+
+@pytest.fixture
+def root_logger() -> Iterator[logging.Logger]:
+    root = logging.getLogger()
+    handlers, level = list(root.handlers), root.level
+    yield root
+    root.handlers[:] = handlers
+    root.setLevel(level)
+
+
+def _written(capture: CapturedLog, text: str) -> None:
+    capture._push(text)  # noqa: SLF001
+
+
+def test_a_capture_keeps_what_the_logger_wrote(root_logger: logging.Logger) -> None:
+    capture = init_logging_captured()
+    logging.getLogger("scan").info("first")
+    logging.getLogger("scan").warning("second")
+    lines = capture.contents().splitlines()
+    assert len(lines) == 2
+    assert lines[0].endswith("[INFO] [scan] first")
+    assert lines[1].endswith("[WARNING] [scan] second")
+    assert root_logger.handlers
+
+
+def test_the_copy_has_no_color_codes(root_logger: logging.Logger) -> None:
+    capture = init_logging_captured()
+    logging.getLogger("scan").error("boom")
+    assert "\x1b" not in capture.contents()
+    assert root_logger.handlers
+
+
+def test_the_copy_is_the_same_in_production(
+    monkeypatch: pytest.MonkeyPatch, root_logger: logging.Logger
+) -> None:
+    monkeypatch.setenv("CI_COMMIT_REF_NAME", "trunk")
+    capture = init_logging_captured()
+    logging.getLogger("scan").info("plain")
+    assert capture.contents().endswith("[INFO] [scan] plain\n")
+    assert root_logger.handlers
+
+
+def test_a_traceback_is_kept(root_logger: logging.Logger) -> None:
+    capture = CapturedLog()
+    root_logger.addHandler(CaptureHandler(capture))
+    root_logger.setLevel(logging.INFO)
+    try:
+        message = "bad value"
+        raise ValueError(message)  # noqa: TRY301
+    except ValueError:
+        logging.getLogger("scan").exception("failed")
+    assert "Traceback" in capture.contents()
+    assert "ValueError: bad value" in capture.contents()
+
+
+def test_a_long_log_is_kept_whole() -> None:
+    capture = CapturedLog()
+    lines = [f"line {number}\n" for number in range(100_000)]
+    for line in lines:
+        _written(capture, line)
+    assert capture.contents() == "".join(lines)

{fluidattacks_core_logging-12.0.0 → fluidattacks_core_logging-12.2.0}/tests/test_logging.py

@@ -1,10 +1,20 @@
+import io
 import logging
 import sys
+import threading
+import time
+from queue import Queue
+from typing import cast
 
 import pytest
 import simplejson as json
 
 from fluidattacks_core.logging import init_logging
+from fluidattacks_core.logging.handlers import (
+    CustomQueueHandler,
+    ProductionAsyncHandler,
+    TelemetryAsyncHandler,
+)
 from fluidattacks_core.logging.utils import set_telemetry_metadata
 
 
@@ -321,3 +331,159 @@ def test_colorful_formatter_uses_colors_for_warning(
     assert "\x1b[0m" in log_message
     assert "[WARNING] [product]" in log_message
     assert "A warning message" in log_message
+
+
+def _listener_consumes_new_records(handler: ProductionAsyncHandler | TelemetryAsyncHandler) -> bool:
+    queue = handler.queue
+    assert isinstance(queue, Queue)
+
+    record = logging.LogRecord("test", logging.INFO, __file__, 1, "Test message", None, None)
+    queue.put_nowait(record)
+    time.sleep(0.2)
+
+    return queue.empty()
+
+
+def test_custom_queue_handler_defaults_leave_no_listener() -> None:
+    # A fresh handler carries no listener on any interpreter: the class default
+    # leaves it empty, and `QueueHandler.__init__` clears it on Python 3.12+.
+    # Attaching is therefore the only thing that can install one, which the
+    # subclass tests below observe.
+    queue: Queue[logging.LogRecord] = Queue()
+
+    handler = CustomQueueHandler(queue)
+
+    assert handler.listener is None
+    assert handler.shutting_down is False
+
+
+def test_production_async_handler_ends_init_with_a_running_listener() -> None:
+    handler = ProductionAsyncHandler(io.StringIO())
+    listener = handler.listener
+
+    handler.close()
+
+    assert listener is not None
+    assert isinstance(handler.queue, Queue)
+
+
+def test_telemetry_async_handler_ends_init_with_a_running_listener() -> None:
+    handler = TelemetryAsyncHandler("test-service", "test-source", "test-token")
+    listener = handler.listener
+
+    handler.close()
+
+    assert listener is not None
+    assert isinstance(handler.queue, Queue)
+
+
+def test_production_async_handler_close_stops_listener_and_is_idempotent() -> None:
+    handler = ProductionAsyncHandler(io.StringIO())
+
+    handler.close()
+    handler.close()
+
+    assert not _listener_consumes_new_records(handler)
+
+
+def test_telemetry_async_handler_close_stops_listener_and_is_idempotent() -> None:
+    handler = TelemetryAsyncHandler("test-service", "test-source", "test-token")
+
+    handler.close()
+    handler.close()
+
+    assert not _listener_consumes_new_records(handler)
+
+
+def test_async_handler_init_leaves_a_closable_handler() -> None:
+    # The class-level defaults make a close() racing __init__ a safe no-op, but
+    # __init__ must still finish with a handler that a later close() can stop:
+    # a listener left running behind an already-true shutting_down would never
+    # be drained.
+    handler = ProductionAsyncHandler(io.StringIO())
+
+    assert handler.shutting_down is False
+    assert handler.listener is not None
+
+    handler.close()
+
+    assert not _listener_consumes_new_records(handler)
+
+
+class _BlockedStream(io.StringIO):
+    """Stream whose writes wait for `release`, keeping the listener busy."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.release = threading.Event()
+
+    def write(self, s: str) -> int:
+        self.release.wait(timeout=5)
+        return super().write(s)
+
+
+def _queue_of(handler: ProductionAsyncHandler) -> Queue[logging.LogRecord]:
+    return cast("Queue[logging.LogRecord]", handler.queue)
+
+
+def _record(message: str) -> logging.LogRecord:
+    return logging.LogRecord("test", logging.INFO, __file__, 0, message, None, None)
+
+
+def test_production_async_handler_is_unbounded_by_default() -> None:
+    handler = ProductionAsyncHandler(io.StringIO())
+
+    assert _queue_of(handler).maxsize == 0
+    assert handler.dropped == 0
+
+    handler.close()
+
+
+def test_production_async_handler_drops_records_when_the_queue_is_full() -> None:
+    stream = _BlockedStream()
+    handler = ProductionAsyncHandler(stream, max_queue_size=2)
+    total = 10
+
+    for index in range(total):
+        handler.emit(_record(f"message {index}"))
+
+    # One record may be held by the busy listener, the rest wait in the queue.
+    assert _queue_of(handler).qsize() == 2
+    assert total - 3 <= handler.dropped <= total - 2
+
+    stream.release.set()
+    handler.close()
+
+
+def test_production_async_handler_calls_on_drop_once_per_dropped_record() -> None:
+    drops: list[int] = []
+
+    class _Reporting(ProductionAsyncHandler):
+        def on_drop(self) -> None:
+            drops.append(1)
+
+    stream = _BlockedStream()
+    handler = _Reporting(stream, max_queue_size=1)
+
+    for index in range(5):
+        handler.emit(_record(f"message {index}"))
+
+    assert len(drops) == handler.dropped
+    assert handler.dropped >= 3
+
+    stream.release.set()
+    handler.close()
+
+
+def test_production_async_handler_closes_with_a_full_queue() -> None:
+    stream = _BlockedStream()
+    handler = ProductionAsyncHandler(stream, max_queue_size=1)
+
+    for index in range(4):
+        handler.emit(_record(f"message {index}"))
+    stream.release.set()
+    handler.close()
+
+    assert handler.listener is not None
+    assert handler.shutting_down is True
+    assert not _listener_consumes_new_records(handler)

{fluidattacks_core_logging-12.0.0 → fluidattacks_core_logging-12.2.0}/uv.lock

@@ -148,7 +148,7 @@ wheels = [
 
 [[package]]
 name = "fluidattacks-core-logging"
-version = "12.0.0"
+version = "12.2.0"
 source = { editable = "." }
 dependencies = [
     { name = "python-json-logger" },

fluidattacks_core_logging-12.0.0/.envrc

@@ -1 +0,0 @@
-use_flake ".#python311.devShell"

fluidattacks_core_logging-12.0.0/.gitignore

@@ -1,5 +0,0 @@
-target/
-.direnv/
-.venv/
-.vscode/settings.json
-.zed/settings.json

fluidattacks_core_logging-12.0.0/build/default.nix

@@ -1,19 +0,0 @@
-{ src, workspace_root }:
-{
-  inherit src workspace_root;
-  root_path = "develops/fluidattacks-core/python/logging";
-  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_logging-12.0.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_logging-12.0.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_logging-12.0.0/flake.nix

@@ -1,29 +0,0 @@
-{
-  description = "Fluid Attacks Core logging 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;
-    };
-}