fairagro-middleware-shared 12.2.2.dev37__tar.gz → 12.2.2.dev40__tar.gz

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

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

{fairagro_middleware_shared-12.2.2.dev37 → fairagro_middleware_shared-12.2.2.dev40}/src/middleware/shared/security/__init__.py

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

fairagro_middleware_shared-12.2.2.dev40/src/middleware/shared/security/url_str.py

@@ -0,0 +1,83 @@
+"""URL value type that redacts HTTP(S) userinfo on ordinary stringification."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import GetCoreSchemaHandler
+from pydantic_core import PydanticCustomError, core_schema
+
+from middleware.shared.security.url_redact import redact_url_userinfo
+
+
+class UrlStr:
+    """Credential-bearing URL: ``str()`` redacts userinfo; ``unredacted()`` for Git.
+
+    Use this instead of plain ``str`` (or fully opaque ``SecretStr``) for remotes
+    that may embed oauth2 tokens in the URL. Host and path remain visible after
+    redaction for ops diagnostics.
+    """
+
+    __slots__ = ("_url",)
+
+    def __init__(self, url: str) -> None:
+        """Wrap *url*; may contain userinfo credentials."""
+        self._url = url
+
+    def unredacted(self) -> str:
+        """Return the full URL including credentials (Git CLI / GitPython only)."""
+        return self._url
+
+    def __str__(self) -> str:
+        """Redacted form safe for logs, traces, and diagnostics."""
+        return redact_url_userinfo(self._url)
+
+    def __repr__(self) -> str:
+        """Repr uses the redacted form so tokens never appear in debug output."""
+        return f"UrlStr({str(self)!r})"
+
+    def __eq__(self, other: object) -> bool:
+        """Compare on the raw URL; also accepts an equal plain ``str``."""
+        if isinstance(other, UrlStr):
+            return self._url == other._url
+        if isinstance(other, str):
+            return self._url == other
+        return NotImplemented
+
+    def __hash__(self) -> int:
+        """Hash the raw URL so equal ``UrlStr`` values collide correctly."""
+        return hash(self._url)
+
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls,
+        _source: type[Any],
+        _handler: GetCoreSchemaHandler,
+    ) -> core_schema.CoreSchema:
+        """Accept ``str`` or ``UrlStr``; serialize as the redacted string."""
+
+        def _validate(value: object) -> UrlStr:
+            if isinstance(value, UrlStr):
+                return value
+            if isinstance(value, str):
+                return UrlStr(value)
+            raise PydanticCustomError(
+                "url_str_type",
+                "UrlStr input should be a str or UrlStr",
+            )
+
+        python_schema = core_schema.no_info_plain_validator_function(_validate)
+        return core_schema.json_or_python_schema(
+            python_schema=core_schema.union_schema([
+                core_schema.is_instance_schema(cls),
+                python_schema,
+            ]),
+            json_schema=core_schema.no_info_after_validator_function(
+                _validate,
+                core_schema.str_schema(),
+            ),
+            serialization=core_schema.plain_serializer_function_ser_schema(
+                str,
+                when_used="always",
+            ),
+        )

fairagro_middleware_shared-12.2.2.dev40/tests/unit/test_url_str.py

@@ -0,0 +1,51 @@
+"""Tests for UrlStr redacting URL type."""
+
+import pytest
+from pydantic import BaseModel, ValidationError
+
+from middleware.shared.security import UrlStr
+
+
+def test_url_str_str_and_repr_redact_userinfo() -> None:
+    """Ordinary string conversion hides oauth2 userinfo; host/path remain."""
+    url = UrlStr("https://oauth2:secret-token@gitlab.example.com/group/repo.git")
+    assert str(url) == "https://***@gitlab.example.com/group/repo.git"
+    assert "secret-token" not in str(url)
+    assert "secret-token" not in repr(url)
+    assert "gitlab.example.com/group/repo.git" in str(url)
+
+
+def test_url_str_unredacted_returns_raw() -> None:
+    """Explicit accessor returns the full credential-bearing URL."""
+    raw = "https://oauth2:secret-token@gitlab.example.com/group/repo.git"
+    assert UrlStr(raw).unredacted() == raw
+
+
+def test_url_str_equality_and_hash() -> None:
+    """Equality and hashing use the raw URL (including vs plain str)."""
+    raw = "https://oauth2:tok@host/r.git"
+    a = UrlStr(raw)
+    b = UrlStr(raw)
+    assert a == b
+    assert a == raw
+    assert hash(a) == hash(b)
+    assert a != UrlStr("https://other.example/r.git")
+
+
+def test_url_str_pydantic_field_accepts_str_and_url_str() -> None:
+    """Model fields typed as UrlStr accept str or UrlStr; dump is redacted."""
+
+    class Model(BaseModel):
+        repo: UrlStr
+
+    # model_validate exercises str→UrlStr coercion (constructor is typed as UrlStr only).
+    from_str = Model.model_validate({"repo": "https://oauth2:secret@host/r.git"})
+    assert from_str.repo.unredacted() == "https://oauth2:secret@host/r.git"
+    assert from_str.model_dump()["repo"] == "https://***@host/r.git"
+
+    wrapped = UrlStr("https://oauth2:secret@host/r.git")
+    from_url = Model(repo=wrapped)
+    assert from_url.repo is wrapped or from_url.repo == wrapped
+
+    with pytest.raises(ValidationError):
+        Model.model_validate({"repo": 123})