documente_shared 0.1.200__tar.gz → 0.1.201__tar.gz

{documente_shared-0.1.200 → documente_shared-0.1.201}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: documente_shared
-Version: 0.1.200
+Version: 0.1.201
 Summary: Shared utilities for LlamitAI projects
 Author-email: Tech <tech@llamitai.com>
 License: MIT

documente_shared-0.1.201/documente_shared/domain/entities/uif_registry.py

@@ -0,0 +1,96 @@
+from dataclasses import dataclass, field
+from datetime import date, datetime
+from decimal import Decimal
+from uuid import UUID, uuid4
+
+from documente_shared.application.payloads import camel_to_snake, snake_to_camel
+from documente_shared.domain.helpers.values import (
+    optional_date,
+    optional_datetime,
+    optional_decimal,
+    optional_text,
+    optional_uuid,
+)
+
+
+@dataclass
+class UIFRegistry:
+    uuid: UUID = field(default_factory=uuid4)
+    paternal_last_name: str | None = None
+    maternal_last_name: str | None = None
+    first_name: str | None = None
+    identity_document_number: str | None = None
+    identity_document_extension: str | None = None
+    court_name: str | None = None
+    process_type: str | None = None
+    circular_id: str | None = None
+    circular_issue_date: date | None = None
+    involved_amount: Decimal | None = None
+    relation_type: str | None = None
+    due_diligence: bool | None = None
+    illicit_gains_legitimation: bool | None = None
+    document_digest: str | None = None
+    created_at: datetime | None = None
+
+    @property
+    def full_name(self) -> str:
+        parts = [self.paternal_last_name, self.maternal_last_name, self.first_name]
+        return " ".join(part for part in parts if part)
+
+    @property
+    def is_identifiable(self) -> bool:
+        return bool(self.full_name)
+
+    @property
+    def to_dict(self) -> dict:
+        return {
+            "uuid": str(self.uuid),
+            "document_digest": self.document_digest,
+            "paternal_last_name": self.paternal_last_name,
+            "maternal_last_name": self.maternal_last_name,
+            "first_name": self.first_name,
+            "full_name": self.full_name,
+            "identity_document_number": self.identity_document_number,
+            "identity_document_extension": self.identity_document_extension,
+            "court_name": self.court_name,
+            "process_type": self.process_type,
+            "circular_id": self.circular_id,
+            "circular_issue_date": (
+                self.circular_issue_date.isoformat() if self.circular_issue_date else None
+            ),
+            "involved_amount": (
+                str(self.involved_amount) if self.involved_amount is not None else None
+            ),
+            "relation_type": self.relation_type,
+            "due_diligence": self.due_diligence,
+            "illicit_gains_legitimation": self.illicit_gains_legitimation,
+            "created_at": self.created_at.isoformat() if self.created_at else None,
+        }
+
+    @property
+    def to_payload(self) -> dict:
+        return snake_to_camel(self.to_dict)
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "UIFRegistry":
+        normalized = camel_to_snake(data)
+        return cls(
+            uuid=optional_uuid(normalized.get("uuid")) or uuid4(),
+            document_digest=optional_text(normalized.get("document_digest")),
+            paternal_last_name=optional_text(normalized.get("paternal_last_name")),
+            maternal_last_name=optional_text(normalized.get("maternal_last_name")),
+            first_name=optional_text(normalized.get("first_name")),
+            identity_document_number=optional_text(normalized.get("identity_document_number")),
+            identity_document_extension=optional_text(
+                normalized.get("identity_document_extension")
+            ),
+            court_name=optional_text(normalized.get("court_name")),
+            process_type=optional_text(normalized.get("process_type")),
+            circular_id=optional_text(normalized.get("circular_id")),
+            circular_issue_date=optional_date(normalized.get("circular_issue_date")),
+            involved_amount=optional_decimal(normalized.get("involved_amount")),
+            relation_type=optional_text(normalized.get("relation_type")),
+            due_diligence=normalized.get("due_diligence"),
+            illicit_gains_legitimation=normalized.get("illicit_gains_legitimation"),
+            created_at=optional_datetime(normalized.get("created_at")),
+        )

documente_shared-0.1.201/documente_shared/domain/helpers/values.py

@@ -0,0 +1,62 @@
+from datetime import date, datetime
+from decimal import Decimal, InvalidOperation
+from uuid import UUID
+
+
+def optional_str(input_value: object | None = None) -> str | None:
+    if input_value is None:
+        return None
+    return str(input_value)
+
+
+def optional_text(input_value: object | None = None) -> str | None:
+    if input_value is None:
+        return None
+    text = str(input_value).strip()
+    return text or None
+
+
+def optional_datetime_str(input_datetime: datetime | None = None) -> str | None:
+    if input_datetime is None:
+        return None
+    return input_datetime.isoformat()
+
+
+def optional_uuid(input_value: object | None = None) -> UUID | None:
+    if input_value is None or isinstance(input_value, UUID):
+        return input_value
+    try:
+        return UUID(str(input_value))
+    except ValueError:
+        return None
+
+
+def optional_date(input_value: object | None = None) -> date | None:
+    if input_value is None:
+        return None
+    if isinstance(input_value, datetime):
+        return input_value.date()
+    if isinstance(input_value, date):
+        return input_value
+    try:
+        return date.fromisoformat(str(input_value))
+    except ValueError:
+        return None
+
+
+def optional_datetime(input_value: object | None = None) -> datetime | None:
+    if input_value is None or isinstance(input_value, datetime):
+        return input_value
+    try:
+        return datetime.fromisoformat(str(input_value))
+    except ValueError:
+        return None
+
+
+def optional_decimal(input_value: object | None = None) -> Decimal | None:
+    if input_value is None or isinstance(input_value, Decimal):
+        return input_value
+    try:
+        return Decimal(str(input_value))
+    except InvalidOperation:
+        return None

documente_shared-0.1.201/documente_shared/domain/repositories/uif_registry.py

@@ -0,0 +1,13 @@
+from abc import ABC, abstractmethod
+
+from documente_shared.domain.entities.uif_registry import UIFRegistry
+
+
+class UIFRegistryRepository(ABC):
+    @abstractmethod
+    def set_document_uif_registries(
+        self,
+        document_digest: str,
+        registries: list[UIFRegistry],
+    ) -> list[UIFRegistry]:
+        raise NotImplementedError

documente_shared-0.1.201/documente_shared/infrastructure/repositories/http_uif_registry.py

@@ -0,0 +1,47 @@
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+import structlog
+
+from documente_shared.domain.entities.uif_registry import UIFRegistry
+from documente_shared.domain.repositories.uif_registry import UIFRegistryRepository
+from documente_shared.infrastructure.documente_client import DocumenteClientMixin
+
+if TYPE_CHECKING:
+    from requests import Response
+
+logger = structlog.get_logger()
+
+
+@dataclass
+class HttpUIFRegistryRepository(
+    DocumenteClientMixin,
+    UIFRegistryRepository,
+):
+    def set_document_uif_registries(
+        self,
+        document_digest: str,
+        registries: list[UIFRegistry],
+    ) -> list[UIFRegistry]:
+        payload = {
+            "document_digest": document_digest,
+            "registries": [registry.to_payload for registry in registries],
+        }
+        logger.info(
+            "[shared.uif_registry.persisting]",
+            document_digest=document_digest,
+            registries=len(registries),
+        )
+        response: Response = self.session.post(
+            url=f"{self.api_url}/v1/documents/uif-registry/",
+            json=payload,
+        )
+        if not self._is_success(response):
+            logger.warning(
+                "[shared.uif_registry.persist_error]",
+                document_digest=document_digest,
+                status_code=response.status_code,
+                response=response.text,
+            )
+            return []
+        return self._parse_list(response, UIFRegistry.from_dict)

{documente_shared-0.1.200 → documente_shared-0.1.201}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "documente_shared"
-version = "0.1.200"
+version = "0.1.201"
 description = "Shared utilities for LlamitAI projects"
 authors = [{ name = "Tech", email = "tech@llamitai.com" }]
 license = { text = "MIT" }

{documente_shared-0.1.200 → documente_shared-0.1.201}/uv.lock

@@ -154,7 +154,7 @@ wheels = [
 
 [[package]]
 name = "documente-shared"
-version = "0.1.200"
+version = "0.1.201"
 source = { editable = "." }
 dependencies = [
     { name = "boto3" },

documente_shared-0.1.200/documente_shared/domain/helpers/values.py

@@ -1,13 +0,0 @@
-from datetime import datetime
-
-
-def optional_str(input_value: object | None = None) -> str | None:
-    if input_value is None:
-        return None
-    return str(input_value)
-
-
-def optional_datetime_str(input_datetime: datetime | None = None) -> str | None:
-    if input_datetime is None:
-        return None
-    return input_datetime.isoformat()