fairagro-middleware-shared 12.2.0__tar.gz → 12.2.2.dev37__tar.gz

{fairagro_middleware_shared-12.2.0 → fairagro_middleware_shared-12.2.2.dev37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: fairagro-middleware-shared
-Version: 12.2.0
+Version: 12.2.2.dev37
 Summary: The FAIRagro advanced middleware shared components
 Requires-Python: >=3.12
 Requires-Dist: opentelemetry-api>=1.26.0

{fairagro_middleware_shared-12.2.0 → fairagro_middleware_shared-12.2.2.dev37}/src/middleware/shared/api_models/common/rocrate.py

@@ -1,20 +1,22 @@
 """RO-Crate payload validation for ARC upload requests."""
 
 from functools import cached_property
-from typing import Annotated, Any, Self
+from typing import Annotated, Self, cast
 
 from pydantic import BaseModel, ConfigDict, Field, model_validator
 
+from middleware.shared.json_types import JsonValue, RoCrateContent, RoCrateGraphNode
 
-def _root_dataset_entity(graph: list[dict[str, Any]]) -> dict[str, Any] | None:
+
+def _root_dataset_entity(graph: list[RoCrateGraphNode]) -> RoCrateGraphNode | None:
     """Return the RO-Crate root data entity (``@id``: ``./``) from ``@graph``."""
     for item in graph:
-        if isinstance(item, dict) and item.get("@id") == "./":
+        if item.get("@id") == "./":
             return item
     return None
 
 
-def _normalize_text_field(value: object) -> str | None:
+def _normalize_text_field(value: JsonValue | None) -> str | None:
     if isinstance(value, list):
         value = value[0] if value else None
     if isinstance(value, dict):
@@ -25,7 +27,7 @@ def _normalize_text_field(value: object) -> str | None:
     return text or None
 
 
-def _extract_identifier(root: dict[str, Any]) -> str:
+def _extract_identifier(root: RoCrateGraphNode) -> str:
     """Extract and normalize the required ``identifier`` from the root data entity."""
     identifier = _normalize_text_field(root.get("identifier"))
     if not identifier:
@@ -34,12 +36,12 @@ def _extract_identifier(root: dict[str, Any]) -> str:
     return identifier
 
 
-def _extract_optional_text(root: dict[str, Any], field: str) -> str | None:
+def _extract_optional_text(root: RoCrateGraphNode, field: str) -> str | None:
     """Extract an optional text field from the root data entity."""
     return _normalize_text_field(root.get(field))
 
 
-def validate_root_dataset(graph: list[dict[str, Any]]) -> dict[str, Any]:
+def validate_root_dataset(graph: list[RoCrateGraphNode]) -> RoCrateGraphNode:
     """Validate ``@graph`` contains a root data entity with a non-empty ``identifier``."""
     root = _root_dataset_entity(graph)
     if root is None:
@@ -54,8 +56,8 @@ class RoCratePayload(BaseModel):
 
     model_config = ConfigDict(populate_by_name=True, extra="forbid")
 
-    context: Annotated[Any, Field(alias="@context")]
-    graph: Annotated[list[dict[str, Any]], Field(alias="@graph", min_length=1)]
+    context: Annotated[JsonValue, Field(alias="@context")]
+    graph: Annotated[list[RoCrateGraphNode], Field(alias="@graph", min_length=1)]
 
     @model_validator(mode="after")
     def validate_root_dataset_fields(self) -> Self:
@@ -64,7 +66,7 @@ class RoCratePayload(BaseModel):
         return self
 
     @cached_property
-    def _root(self) -> dict[str, Any]:
+    def _root(self) -> RoCrateGraphNode:
         """Root data entity dict (validated during model construction)."""
         root = _root_dataset_entity(self.graph)
         if root is None:
@@ -86,3 +88,10 @@ class RoCratePayload(BaseModel):
     def description(self) -> str | None:
         """Optional RO-Crate ``description`` from the root data entity."""
         return _extract_optional_text(self._root, "description")
+
+    def to_content(self) -> RoCrateContent:
+        """Return the wire-format RO-Crate document."""
+        return {
+            "@context": self.context,
+            "@graph": cast(JsonValue, self.graph),
+        }

fairagro_middleware_shared-12.2.2.dev37/src/middleware/shared/config/logging.py

@@ -0,0 +1,91 @@
+"""Logging configuration module.
+
+This module provides functionality to configure logging levels for all handlers
+and the root logger across the application, and installs URL-userinfo redaction
+so oauth2/Git credentials do not appear in formatted log output.
+"""
+
+from __future__ import annotations
+
+import logging
+
+from middleware.shared.config.config_base import LogLevel
+from middleware.shared.security.url_redact import redact_url_userinfo
+
+
+class RedactingFormatter(logging.Formatter):
+    """Wrap another formatter and redact URL userinfo in the final log line."""
+
+    def __init__(self, wrapped: logging.Formatter | None = None) -> None:
+        """Initialize with an optional underlying formatter.
+
+        Copies the wrapped ``_fmt`` / ``datefmt`` into this instance so
+        ``handler.formatter._fmt`` still reflects the real log layout.
+        """
+        self._wrapped = wrapped if wrapped is not None else logging.Formatter()
+        super().__init__(
+            fmt=getattr(self._wrapped, "_fmt", None),
+            datefmt=getattr(self._wrapped, "datefmt", None),
+        )
+
+    def format(self, record: logging.LogRecord) -> str:
+        """Format the record, then strip URL credentials from the result."""
+        return redact_url_userinfo(self._wrapped.format(record))
+
+
+class _RedactingLogFilter(logging.Filter):
+    """Scrub URL userinfo from record message/args before handlers format."""
+
+    def filter(self, record: logging.LogRecord) -> bool:  # noqa: PLR6301
+        """Redact ``record.msg`` / string ``args`` in place."""
+        if isinstance(record.msg, str):
+            record.msg = redact_url_userinfo(record.msg)
+        if isinstance(record.args, dict):
+            record.args = {
+                key: redact_url_userinfo(value) if isinstance(value, str) else value
+                for key, value in record.args.items()
+            }
+        elif isinstance(record.args, tuple):
+            record.args = tuple(redact_url_userinfo(arg) if isinstance(arg, str) else arg for arg in record.args)
+        return True
+
+
+def install_url_userinfo_redaction(logger: logging.Logger | None = None) -> None:
+    """Ensure handlers redact ``https://userinfo@`` in every formatted log line.
+
+    Safe to call repeatedly; handlers that already use :class:`RedactingFormatter`
+    are left unchanged. Also attaches a logger-level filter so message/args are
+    scrubbed when possible.
+    """
+    target = logging.getLogger() if logger is None else logger
+    if not any(isinstance(f, _RedactingLogFilter) for f in target.filters):
+        target.addFilter(_RedactingLogFilter())
+    for handler in target.handlers:
+        if not isinstance(handler, logging.Handler):
+            # Skip test doubles / non-stdlib handlers without a real formatter API.
+            continue
+        if not any(isinstance(f, _RedactingLogFilter) for f in handler.filters):
+            handler.addFilter(_RedactingLogFilter())
+        current = handler.formatter
+        if isinstance(current, RedactingFormatter):
+            continue
+        if current is not None and not isinstance(current, logging.Formatter):
+            continue
+        handler.setFormatter(RedactingFormatter(current))
+
+
+def configure_logging(level: LogLevel) -> None:
+    """Configure logging level for all handlers.
+
+    Args:
+        level: Logging level to set for all handlers and root logger.
+    """
+    root = logging.getLogger()
+    if root.handlers:
+        # vorhandene Handler neu konfigurieren
+        for h in root.handlers:
+            h.setLevel(level)
+        root.setLevel(level)
+    else:
+        logging.basicConfig(level=level)
+    install_url_userinfo_redaction(root)

fairagro_middleware_shared-12.2.2.dev37/src/middleware/shared/json_types.py

@@ -0,0 +1,12 @@
+"""JSON value types for wire-format documents (RO-Crate, CouchDB, catalog files)."""
+
+from __future__ import annotations
+
+type JsonPrimitive = str | int | float | bool | None
+type JsonValue = JsonPrimitive | list[JsonValue] | dict[str, JsonValue]
+
+type JsonObject = dict[str, JsonValue]
+type RoCrateContent = JsonObject
+type RoCrateGraphNode = JsonObject
+type CatalogDatasetRecord = JsonObject
+type CouchDbDocument = JsonObject

fairagro_middleware_shared-12.2.2.dev37/src/middleware/shared/security/__init__.py

@@ -0,0 +1,5 @@
+"""Security helpers shared across middleware components."""
+
+from middleware.shared.security.url_redact import redact_url_userinfo
+
+__all__ = ["redact_url_userinfo"]

fairagro_middleware_shared-12.2.2.dev37/src/middleware/shared/security/url_redact.py

@@ -0,0 +1,13 @@
+"""Redact credentials embedded in URL userinfo (e.g. oauth2 tokens in Git remotes)."""
+
+from __future__ import annotations
+
+import re
+
+# http(s)://user:pass@host or http(s)://token@host — used by Git HTTPS remotes.
+_URL_USERINFO = re.compile(r"(https?://)([^/\s\"'<>]+)@", re.IGNORECASE)
+
+
+def redact_url_userinfo(text: str) -> str:
+    """Replace URL userinfo with ``***@`` so tokens never appear in logs/events."""
+    return _URL_USERINFO.sub(r"\1***@", text)

fairagro_middleware_shared-12.2.2.dev37/tests/unit/test_url_redact.py

@@ -0,0 +1,84 @@
+"""Tests for URL userinfo redaction."""
+
+import logging
+
+from middleware.shared.config.logging import RedactingFormatter, install_url_userinfo_redaction
+from middleware.shared.security.url_redact import redact_url_userinfo
+
+
+def test_redact_url_userinfo_oauth2_token() -> None:
+    """oauth2 tokens in https URLs are replaced with ***."""
+    raw = "push failed: https://oauth2:secret-token@gitlab.example.com/group/repo.git"
+    assert redact_url_userinfo(raw) == "push failed: https://***@gitlab.example.com/group/repo.git"
+    assert "secret-token" not in redact_url_userinfo(raw)
+
+
+def test_redacting_formatter_preserves_wrapped_fmt() -> None:
+    """Outer formatter exposes the same _fmt as the wrapped layout."""
+    inner = logging.Formatter("%(asctime)s %(levelname)s %(name)s: %(message)s")
+    outer = RedactingFormatter(inner)
+    assert outer._fmt == inner._fmt  # noqa: SLF001
+
+
+def test_redacting_formatter_covers_message_and_exception_text() -> None:
+    """Formatted log lines (including traceback text) are redacted."""
+    logger = logging.getLogger("test_url_redact_formatter")
+    logger.handlers.clear()
+    logger.propagate = False
+    stream = logging.StreamHandler()
+    stream.setFormatter(RedactingFormatter(logging.Formatter("%(message)s")))
+    logger.addHandler(stream)
+
+    record = logger.makeRecord(
+        logger.name,
+        logging.ERROR,
+        __file__,
+        1,
+        "failed https://oauth2:secret-token@host/repo.git",
+        (),
+        None,
+    )
+    assert "secret-token" not in stream.format(record)
+
+
+def test_install_url_userinfo_redaction_is_idempotent() -> None:
+    """Wrapping handlers twice must not nest forever."""
+    root = logging.getLogger()
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter("%(message)s"))
+    root.addHandler(handler)
+    try:
+        install_url_userinfo_redaction()
+        install_url_userinfo_redaction()
+        assert isinstance(handler.formatter, RedactingFormatter)
+        assert not isinstance(handler.formatter._wrapped, RedactingFormatter)  # noqa: SLF001
+    finally:
+        root.removeHandler(handler)
+
+
+def test_install_url_userinfo_redaction_rewraps_replaced_formatter() -> None:
+    """If a handler formatter is replaced after install, the next install re-wraps."""
+    root = logging.getLogger()
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter("%(message)s"))
+    root.addHandler(handler)
+    try:
+        install_url_userinfo_redaction()
+        assert isinstance(handler.formatter, RedactingFormatter)
+        handler.setFormatter(logging.Formatter("%(levelname)s %(message)s"))
+        install_url_userinfo_redaction()
+        assert isinstance(handler.formatter, RedactingFormatter)
+        assert handler.formatter._fmt == "%(levelname)s %(message)s"  # noqa: SLF001
+        assert "secret-token" not in handler.format(
+            logging.LogRecord(
+                "test",
+                logging.ERROR,
+                __file__,
+                1,
+                "leak https://oauth2:secret-token@host/r.git",
+                (),
+                None,
+            )
+        )
+    finally:
+        root.removeHandler(handler)

fairagro_middleware_shared-12.2.0/src/middleware/shared/config/logging.py

@@ -1,25 +0,0 @@
-"""Logging configuration module.
-
-This module provides functionality to configure logging levels for all handlers
-and the root logger across the application.
-"""
-
-import logging
-
-from middleware.shared.config.config_base import LogLevel
-
-
-def configure_logging(level: LogLevel) -> None:
-    """Configure logging level for all handlers.
-
-    Args:
-        level: Logging level to set for all handlers and root logger.
-    """
-    root = logging.getLogger()
-    if root.handlers:
-        # vorhandene Handler neu konfigurieren
-        for h in root.handlers:
-            h.setLevel(level)
-        root.setLevel(level)
-    else:
-        logging.basicConfig(level=level)