documente_shared 0.1.159__tar.gz → 0.1.161__tar.gz

{documente_shared-0.1.159 → documente_shared-0.1.161}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: documente_shared
-Version: 0.1.159
+Version: 0.1.161
 Summary: Shared utilities for Documente AI projects
 Author-email: Tech <tech@llamitai.com>
 License: MIT

{documente_shared-0.1.159 → documente_shared-0.1.161}/documente_shared/domain/entities/processing_case.py

@@ -7,6 +7,7 @@ from documente_shared.domain.constants import la_paz_tz
 from documente_shared.domain.entities.processing_case_item import ProcessingCaseItem
 from documente_shared.domain.enums.common import ProcessingStatus
 from documente_shared.domain.enums.processing_case import ProcessingCaseType
+from documente_shared.domain.helpers.values import optional_datetime_str
 
 
 @dataclass
@@ -21,6 +22,8 @@ class ProcessingCase(object):
     failed_at: Optional[datetime] = None
     feedback: Optional[list | dict] = None
     completed_at: Optional[datetime] = None
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
     metadata: Optional[dict] = None
     items: Optional[List[ProcessingCaseItem]] = None
 
@@ -30,10 +33,10 @@ class ProcessingCase(object):
     def __eq__(self, other: 'ProcessingCase') -> bool:
         if not other:
             return False
-
         return (
             self.uuid == other.uuid
             and self.name == other.name
+            and self.tenant_slug == other.tenant_slug
             and self.status == other.status
             and self.case_type == other.case_type
             and self.enqueued_at == other.enqueued_at
@@ -41,16 +44,19 @@ class ProcessingCase(object):
             and self.failed_at == other.failed_at
             and self.feedback == other.feedback
             and self.completed_at == other.completed_at
+            and self.created_at == other.created_at
+            and self.updated_at == other.updated_at
             and self.metadata == other.metadata
+            and self.items == other.items
         )
 
     @property
-    def strategy_id(self) ->str:
+    def strategy_id(self) -> str:
         return str(self.case_type)
 
     @property
     def is_procesable(self) -> bool:
-        return self.items and len(self.items) > 0
+        return bool(self.items)
 
     @property
     def is_queue_procesable(self) -> bool:
@@ -86,18 +92,19 @@ class ProcessingCase(object):
                 str(self.case_type)
                 if self.case_type else None
             ),
-            'enqueued_at': self.enqueued_at.isoformat() if self.enqueued_at else None,
-            'started_at': self.started_at.isoformat() if self.started_at else None,
-            'failed_at': self.failed_at.isoformat() if self.failed_at else None,
+            'enqueued_at': optional_datetime_str(self.enqueued_at),
+            'started_at': optional_datetime_str(self.started_at),
+            'failed_at': optional_datetime_str(self.failed_at),
             'feedback': self.feedback,
-            'completed_at': self.completed_at.isoformat() if self.completed_at else None,
             'metadata': self.metadata,
+            'completed_at': optional_datetime_str(self.completed_at),
+            'updated_at': optional_datetime_str(self.updated_at),
             'items': [item.to_dict for item in self.items],
         }
 
     @property
     def to_queue_dict(self) -> dict:
-        data = self.to_dict
+        data = self.to_dict.copy()
         data["items"] = [
             item.to_queue_dict for item in self.items
         ]
@@ -105,7 +112,7 @@ class ProcessingCase(object):
 
     @property
     def to_persist_dict(self) -> dict:
-        persist_data = self.to_dict
+        persist_data = self.to_dict.copy()
         persist_data["items"] = [
             item.to_dict for item in self.items
         ]
@@ -183,8 +190,6 @@ class ProcessingCase(object):
         else:
             self.status = ProcessingStatus.PENDING
 
-
-
     @classmethod
     def from_dict(cls, data: dict) -> 'ProcessingCase':
         return cls(
@@ -202,6 +207,8 @@ class ProcessingCase(object):
             feedback=data.get('feedback'),
             metadata=data.get('metadata', {}),
             completed_at=get_datetime_from_data(input_datetime=data.get('completed_at')),
+            created_at=get_datetime_from_data(input_datetime=data.get('created_at')),
+            updated_at=get_datetime_from_data(input_datetime=data.get('updated_at')),
             items=[
                 ProcessingCaseItem.from_dict(item_dict)
                 for item_dict in data.get('items', [])
@@ -216,4 +223,3 @@ class ProcessingCase(object):
             for item_dict in data.get('items', [])
         ]
         return instance
-

documente_shared-0.1.161/documente_shared/domain/entities/workspace.py

@@ -0,0 +1,63 @@
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional
+from uuid import UUID
+
+from documente_shared.application.time_utils import get_datetime_from_data
+
+
+@dataclass
+class Workspace(object):
+    uuid: UUID
+    name: str
+    tenant_slug: str
+    is_archived: bool = False
+    metadata: Optional[dict] = None
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+    document_types: Optional[list] = None
+
+    def __post_init__(self):
+        self.metadata = self.metadata or {}
+        self.document_types = self.document_types or []
+
+    @property
+    def to_persist_dict(self) -> dict:
+        return {
+            "tenant_slug": self.tenant_slug,
+            "name": self.name,
+            "is_archived": self.is_archived,
+            "metadata": self.metadata or {},
+        }
+
+    @property
+    def to_dict(self) -> dict:
+        return {
+            "uuid": str(self.uuid),
+            "name": self.name,
+            "tenant_slug": self.tenant_slug,
+            "is_archived": self.is_archived,
+            "metadata": self.metadata,
+            "created_at": (
+                self.created_at.isoformat()
+                if self.created_at else None
+            ),
+            "updated_at": (
+                self.updated_at.isoformat()
+                if self.updated_at else None
+            ),
+            "document_types": self.document_types,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'Workspace':
+        return cls(
+            uuid=data.get('uuid'),
+            name=data.get('name'),
+            tenant_slug=data.get('tenant_slug'),
+            is_archived=data.get('is_archived', False),
+            metadata=data.get('metadata', {}),
+            created_at=get_datetime_from_data(input_datetime=data.get('created_at')),
+            updated_at=get_datetime_from_data(input_datetime=data.get('updated_at')),
+            document_types=data.get('document_types', []),
+        )

documente_shared-0.1.161/documente_shared/domain/entities/workspace_document.py

@@ -0,0 +1,138 @@
+from dataclasses import dataclass
+from datetime import datetime
+from decimal import Decimal
+from typing import Optional
+from uuid import UUID
+
+from documente_shared.application.time_utils import get_datetime_from_data
+from documente_shared.domain.entities.in_memory_document import InMemoryDocument
+from documente_shared.domain.enums.common import ProcessingStatus
+from documente_shared.domain.enums.workspace import WorkspaceSource
+from documente_shared.domain.helpers.values import optional_str
+
+
+@dataclass
+class WorkspaceDocument(object):
+    uuid: UUID
+    name: str
+    status: ProcessingStatus
+    tenant_slug: str
+    workspace_id: UUID
+    digest: Optional[str] = None
+    document_type_id: Optional[UUID] = None
+    source: Optional[WorkspaceSource] = None
+    document: Optional[InMemoryDocument] = None
+    document_url: Optional[str] = None
+    processing_time: Optional[Decimal] = None
+    metadata: Optional[dict] = None
+    extraction: Optional[dict] = None
+    uploaded_at: Optional[datetime] = None
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+    started_at: Optional[datetime] = None
+    completed_at: Optional[datetime] = None
+    failed_at: Optional[datetime] = None
+
+    def __post_init__(self):
+        self.metadata = self.metadata or {}
+        self.extraction = self.extraction or {}
+
+    @property
+    def to_persist_dict(self) -> dict:
+        return {
+            "tenant_slug": self.tenant_slug,
+            "workspace_id": str(self.workspace_id),
+            "doctype_id": str(self.document_type_id) if self.document_type_id else None,
+            "name": self.name,
+            "digest": self.digest,
+            "status": str(self.status),
+            "source": optional_str(self.source),
+            "uploaded_at": self.uploaded_at,
+            "started_at": self.started_at,
+            "completed_at": self.completed_at,
+            "failed_at": self.failed_at,
+            "processing_time": self.processing_time,
+            "metadata": self.metadata or {},
+            "extraction": self.extraction or {},
+        }
+
+    @property
+    def to_dict(self) -> dict:
+        return {
+            "uuid": str(self.uuid),
+            "name": self.name,
+            "digest": self.digest,
+            "status": str(self.status),
+            "tenant_slug": self.tenant_slug,
+            "workspace_id": str(self.workspace_id),
+            "document_type_id": str(self.document_type_id) if self.document_type_id else None,
+            "source": optional_str(self.source),
+            "document": (
+                self.document.to_dict
+                if self.document else None
+            ),
+            "document_url": self.document_url,
+            "processing_time": (
+                str(self.processing_time)
+                if self.processing_time else None
+            ),
+            "metadata": self.metadata,
+            "extraction": self.extraction,
+            "uploaded_at": (
+                self.uploaded_at.isoformat()
+                if self.uploaded_at else None
+            ),
+            "created_at": (
+                self.created_at.isoformat()
+                if self.created_at else None
+            ),
+            "updated_at": (
+                self.updated_at.isoformat()
+                if self.updated_at else None
+            ),
+            "started_at": (
+                self.started_at.isoformat()
+                if self.started_at else None
+            ),
+            "completed_at": (
+                self.completed_at.isoformat()
+                if self.completed_at else None
+            ),
+            "failed_at": (
+                self.failed_at.isoformat()
+                if self.failed_at else None
+            ),
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'WorkspaceDocument':
+        return cls(
+            uuid=data.get('uuid'),
+            name=data.get('name'),
+            digest=data.get('digest'),
+            status=ProcessingStatus.from_value(data.get('status')),
+            tenant_slug=data.get('tenant_slug'),
+            workspace_id=data.get('workspace_id'),
+            document_type_id=data.get('document_type_id'),
+            source=(
+                WorkspaceSource.from_value(data.get('source'))
+                if data.get('source') else None
+            ),
+            document=(
+                InMemoryDocument.from_dict(data.get('document'))
+                if data.get('document') else None
+            ),
+            document_url=data.get('document_url'),
+            processing_time=(
+                Decimal(data.get('processing_time'))
+                if data.get('processing_time') else None
+            ),
+            metadata=data.get('metadata', {}),
+            extraction=data.get('extraction', {}),
+            uploaded_at=get_datetime_from_data(input_datetime=data.get('uploaded_at')),
+            created_at=get_datetime_from_data(input_datetime=data.get('created_at')),
+            updated_at=get_datetime_from_data(input_datetime=data.get('updated_at')),
+            started_at=get_datetime_from_data(input_datetime=data.get('started_at')),
+            completed_at=get_datetime_from_data(input_datetime=data.get('completed_at')),
+            failed_at=get_datetime_from_data(input_datetime=data.get('failed_at')),
+        )

documente_shared-0.1.161/documente_shared/domain/entities/workspace_document_filters.py

@@ -0,0 +1,45 @@
+from dataclasses import dataclass
+from typing import List, Optional
+from uuid import UUID
+
+from documente_shared.application.query_params import QueryParams
+from documente_shared.domain.enums.common import ProcessingStatus
+
+
+@dataclass
+class WorkspaceDocumentFilters(object):
+    workspace_id: Optional[UUID] = None
+    sort_order: Optional[str] = None
+    search: Optional[str] = None
+    digest: Optional[str] = None
+    statuses: List[ProcessingStatus] = None
+
+    def __post_init__(self):
+        self.statuses = self.statuses or []
+        self.sort_order = self.sort_order or "desc"
+
+    @property
+    def to_params(self) -> dict:
+        params = {
+            "workspace_id": str(self.workspace_id) if self.workspace_id else None,
+            "sort": self.sort_order,
+            "search": self.search,
+            "digest": self.digest,
+            "statuses": ",".join(str(s) for s in self.statuses) if self.statuses else None,
+        }
+        return {k: v for k, v in params.items() if v is not None}
+
+    @classmethod
+    def from_params(cls, params: QueryParams) -> "WorkspaceDocumentFilters":
+        search_term = params.get_str(key="search", default=None)
+        return cls(
+            workspace_id=params.get_uuid(key="workspace_id", default=None),
+            sort_order=params.get(key="sort", default="desc"),
+            search=search_term.strip() if search_term else None,
+            digest=params.get_str(key="digest", default=None),
+            statuses=params.get_enum_list(
+                key="statuses",
+                enum_class=ProcessingStatus,
+                default=None,
+            ),
+        )

documente_shared-0.1.161/documente_shared/domain/entities/workspace_document_page.py

@@ -0,0 +1,70 @@
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional
+from uuid import UUID
+
+from documente_shared.application.time_utils import get_datetime_from_data
+from documente_shared.domain.entities.in_memory_document import InMemoryDocument
+
+
+@dataclass
+class WorkspaceDocumentPage(object):
+    uuid: UUID
+    tenant_slug: str
+    workspace_id: UUID
+    workspace_document_id: UUID
+    page_number: int
+    page_file: Optional[InMemoryDocument] = None
+    page_file_url: Optional[str] = None
+    created_at: Optional[datetime] = None
+    synced_at: Optional[datetime] = None
+
+    @property
+    def to_persist_dict(self) -> dict:
+        return {
+            "tenant_slug": self.tenant_slug,
+            "workspace_id": str(self.workspace_id),
+            "workspace_document_id": str(self.workspace_document_id),
+            "page_number": self.page_number,
+            "synced_at": self.synced_at,
+        }
+
+    @property
+    def to_dict(self) -> dict:
+        return {
+            "uuid": str(self.uuid),
+            "tenant_slug": self.tenant_slug,
+            "workspace_id": str(self.workspace_id),
+            "workspace_document_id": str(self.workspace_document_id),
+            "page_number": self.page_number,
+            "page_file": (
+                self.page_file.to_dict
+                if self.page_file else None
+            ),
+            "page_file_url": self.page_file_url,
+            "created_at": (
+                self.created_at.isoformat()
+                if self.created_at else None
+            ),
+            "synced_at": (
+                self.synced_at.isoformat()
+                if self.synced_at else None
+            ),
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'WorkspaceDocumentPage':
+        return cls(
+            uuid=data.get('uuid'),
+            tenant_slug=data.get('tenant_slug'),
+            workspace_id=data.get('workspace_id'),
+            workspace_document_id=data.get('workspace_document_id'),
+            page_number=data.get('page_number'),
+            page_file=(
+                InMemoryDocument.from_dict(data.get('page_file'))
+                if data.get('page_file') else None
+            ),
+            page_file_url=data.get('page_file_url'),
+            created_at=get_datetime_from_data(input_datetime=data.get('created_at')),
+            synced_at=get_datetime_from_data(input_datetime=data.get('synced_at')),
+        )

documente_shared-0.1.161/documente_shared/domain/entities/workspace_document_page_filters.py

@@ -0,0 +1,32 @@
+from dataclasses import dataclass
+from typing import Optional
+from uuid import UUID
+
+from documente_shared.application.query_params import QueryParams
+
+
+@dataclass
+class WorkspaceDocumentPageFilters(object):
+    workspace_document_id: Optional[UUID] = None
+    sort_order: Optional[str] = None
+    page_number: Optional[int] = None
+
+    def __post_init__(self):
+        self.sort_order = self.sort_order or "desc"
+
+    @property
+    def to_params(self) -> dict:
+        params = {
+            "workspace_document_id": str(self.workspace_document_id) if self.workspace_document_id else None,
+            "sort": self.sort_order,
+            "page_number": self.page_number,
+        }
+        return {k: v for k, v in params.items() if v is not None}
+
+    @classmethod
+    def from_params(cls, params: QueryParams) -> "WorkspaceDocumentPageFilters":
+        return cls(
+            workspace_document_id=params.get_uuid(key="workspace_document_id", default=None),
+            sort_order=params.get(key="sort", default="desc"),
+            page_number=params.get_int(key="page_number", default=None),
+        )

documente_shared-0.1.161/documente_shared/domain/entities/workspace_filters.py

@@ -0,0 +1,35 @@
+from dataclasses import dataclass
+from typing import Optional
+
+from documente_shared.application.query_params import QueryParams
+
+
+@dataclass
+class WorkspaceFilters(object):
+    sort_order: Optional[str] = None
+    search: Optional[str] = None
+    include_archived: bool = False
+
+    def __post_init__(self):
+        self.sort_order = self.sort_order or "desc"
+
+    @property
+    def to_params(self) -> dict:
+        params = {
+            "sort": self.sort_order,
+            "search": self.search,
+            "include_archived": str(self.include_archived).lower(),
+        }
+        return {k: v for k, v in params.items() if v is not None}
+
+    @classmethod
+    def from_params(cls, params: QueryParams) -> "WorkspaceFilters":
+        search_term = params.get_str(key="search", default=None)
+        return cls(
+            sort_order=params.get(key="sort", default="desc"),
+            search=search_term.strip() if search_term else None,
+            include_archived=params.get_bool(
+                key="include_archived",
+                default=False,
+            ),
+        )

documente_shared-0.1.161/documente_shared/domain/enums/workspace.py

@@ -0,0 +1,19 @@
+from documente_shared.domain.base_enum import BaseEnum
+
+
+class WorkspaceSource(BaseEnum):
+    WEB = "WEB"
+    MOBILE = "MOBILE"
+    TOOLS = "TOOLS"
+
+    @property
+    def is_web(self):
+        return self == self.WEB
+
+    @property
+    def is_mobile(self):
+        return self == self.MOBILE
+
+    @property
+    def is_tools(self):
+        return self == self.TOOLS

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

@@ -0,0 +1,13 @@
+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()

documente_shared-0.1.161/documente_shared/domain/repositories/workspace.py

@@ -0,0 +1,28 @@
+from abc import ABC, abstractmethod
+from typing import Any, List, Optional
+from uuid import UUID
+
+from documente_shared.domain.entities.workspace import Workspace
+from documente_shared.domain.entities.workspace_filters import WorkspaceFilters
+
+
+class WorkspaceRepository(ABC):
+    @abstractmethod
+    def find(self, uuid: UUID) -> Optional[Workspace]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def filter(self, filters: WorkspaceFilters) -> List[Workspace]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def filter_paginated(self, filters: WorkspaceFilters, page_params: Any) -> Any:
+        raise NotImplementedError
+
+    @abstractmethod
+    def persist(self, instance: Workspace) -> Workspace:
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete(self, uuid: UUID) -> None:
+        raise NotImplementedError

documente_shared-0.1.161/documente_shared/domain/repositories/workspace_document.py

@@ -0,0 +1,28 @@
+from abc import ABC, abstractmethod
+from typing import Any, List, Optional
+from uuid import UUID
+
+from documente_shared.domain.entities.workspace_document import WorkspaceDocument
+from documente_shared.domain.entities.workspace_document_filters import WorkspaceDocumentFilters
+
+
+class WorkspaceDocumentRepository(ABC):
+    @abstractmethod
+    def find(self, uuid: UUID) -> Optional[WorkspaceDocument]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def filter(self, filters: WorkspaceDocumentFilters) -> List[WorkspaceDocument]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def filter_paginated(self, filters: WorkspaceDocumentFilters, page_params: Any) -> Any:
+        raise NotImplementedError
+
+    @abstractmethod
+    def persist(self, instance: WorkspaceDocument) -> WorkspaceDocument:
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete(self, uuid: UUID) -> None:
+        raise NotImplementedError

documente_shared-0.1.161/documente_shared/domain/repositories/workspace_document_page.py

@@ -0,0 +1,28 @@
+from abc import ABC, abstractmethod
+from typing import Any, List, Optional
+from uuid import UUID
+
+from documente_shared.domain.entities.workspace_document_page import WorkspaceDocumentPage
+from documente_shared.domain.entities.workspace_document_page_filters import WorkspaceDocumentPageFilters
+
+
+class WorkspaceDocumentPageRepository(ABC):
+    @abstractmethod
+    def find(self, uuid: UUID) -> Optional[WorkspaceDocumentPage]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def filter(self, filters: WorkspaceDocumentPageFilters) -> List[WorkspaceDocumentPage]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def filter_paginated(self, filters: WorkspaceDocumentPageFilters, page_params: Any) -> Any:
+        raise NotImplementedError
+
+    @abstractmethod
+    def persist(self, instance: WorkspaceDocumentPage) -> WorkspaceDocumentPage:
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete(self, uuid: UUID) -> None:
+        raise NotImplementedError

documente_shared-0.1.161/documente_shared/infrastructure/repositories/http_workspace.py

@@ -0,0 +1,71 @@
+from dataclasses import dataclass
+from typing import Any, List, Optional
+from uuid import UUID
+
+from loguru import logger
+from requests import Response
+
+from documente_shared.application.payloads import camel_to_snake
+from documente_shared.domain.entities.workspace import Workspace
+from documente_shared.domain.entities.workspace_filters import WorkspaceFilters
+from documente_shared.domain.repositories.workspace import WorkspaceRepository
+from documente_shared.infrastructure.documente_client import DocumenteClientMixin
+
+
+@dataclass
+class HttpWorkspaceRepository(
+    DocumenteClientMixin,
+    WorkspaceRepository,
+):
+    def find(self, uuid: UUID) -> Optional[Workspace]:
+        response = self.session.get(
+            url=f"{self.api_url}/v1/workspaces/{uuid}/",
+        )
+        if response.status_code not in [200, 201]:
+            return None
+        return self._build_workspace(response)
+
+    def filter(self, filters: WorkspaceFilters) -> List[Workspace]:
+        response = self.session.get(
+            url=f"{self.api_url}/v1/workspaces/",
+            params=filters.to_params,
+        )
+        if response.status_code not in [200, 201]:
+            return []
+        raw_response = response.json()
+        return [
+            Workspace.from_dict(camel_to_snake(item_data))
+            for item_data in raw_response.get('data', [])
+        ]
+
+    def filter_paginated(self, filters: WorkspaceFilters, page_params: Any) -> Any:
+        params = {**filters.to_params}
+        if isinstance(page_params, dict):
+            params.update(page_params)
+        response = self.session.get(
+            url=f"{self.api_url}/v1/workspaces/",
+            params=params,
+        )
+        if response.status_code not in [200, 201]:
+            return {"data": [], "count": 0}
+        return response.json()
+
+    def persist(self, instance: Workspace) -> Workspace:
+        logger.info(f"PERSISTING_WORKSPACE: data={instance.to_persist_dict}")
+        response: Response = self.session.post(
+            url=f"{self.api_url}/v1/workspaces/",
+            json=instance.to_persist_dict,
+        )
+        if response.status_code not in [200, 201]:
+            logger.info(f"PERSISTING_WORKSPACE ERROR: data={response.text}")
+            return instance
+        return self._build_workspace(response)
+
+    def delete(self, uuid: UUID) -> None:
+        self.session.delete(f"{self.api_url}/v1/workspaces/{uuid}/")
+
+    @classmethod
+    def _build_workspace(cls, response: Response) -> Workspace:
+        response_json = response.json()
+        instance_data = response_json.get('data', {})
+        return Workspace.from_dict(camel_to_snake(instance_data))

documente_shared-0.1.161/documente_shared/infrastructure/repositories/http_workspace_document.py

@@ -0,0 +1,71 @@
+from dataclasses import dataclass
+from typing import Any, List, Optional
+from uuid import UUID
+
+from loguru import logger
+from requests import Response
+
+from documente_shared.application.payloads import camel_to_snake
+from documente_shared.domain.entities.workspace_document import WorkspaceDocument
+from documente_shared.domain.entities.workspace_document_filters import WorkspaceDocumentFilters
+from documente_shared.domain.repositories.workspace_document import WorkspaceDocumentRepository
+from documente_shared.infrastructure.documente_client import DocumenteClientMixin
+
+
+@dataclass
+class HttpWorkspaceDocumentRepository(
+    DocumenteClientMixin,
+    WorkspaceDocumentRepository,
+):
+    def find(self, uuid: UUID) -> Optional[WorkspaceDocument]:
+        response = self.session.get(
+            url=f"{self.api_url}/v1/workspace-documents/{uuid}/",
+        )
+        if response.status_code not in [200, 201]:
+            return None
+        return self._build_workspace_document(response)
+
+    def filter(self, filters: WorkspaceDocumentFilters) -> List[WorkspaceDocument]:
+        response = self.session.get(
+            url=f"{self.api_url}/v1/workspaces/{filters.workspace_id}/documents/",
+            params=filters.to_params,
+        )
+        if response.status_code not in [200, 201]:
+            return []
+        raw_response = response.json()
+        return [
+            WorkspaceDocument.from_dict(camel_to_snake(item_data))
+            for item_data in raw_response.get('data', [])
+        ]
+
+    def filter_paginated(self, filters: WorkspaceDocumentFilters, page_params: Any) -> Any:
+        params = {**filters.to_params}
+        if isinstance(page_params, dict):
+            params.update(page_params)
+        response = self.session.get(
+            url=f"{self.api_url}/v1/workspaces/{filters.workspace_id}/documents/",
+            params=params,
+        )
+        if response.status_code not in [200, 201]:
+            return {"data": [], "count": 0}
+        return response.json()
+
+    def persist(self, instance: WorkspaceDocument) -> WorkspaceDocument:
+        logger.info(f"PERSISTING_WORKSPACE_DOCUMENT: data={instance.to_persist_dict}")
+        response: Response = self.session.post(
+            url=f"{self.api_url}/v1/workspaces/{instance.workspace_id}/documents/",
+            json=instance.to_persist_dict,
+        )
+        if response.status_code not in [200, 201]:
+            logger.info(f"PERSISTING_WORKSPACE_DOCUMENT ERROR: data={response.text}")
+            return instance
+        return self._build_workspace_document(response)
+
+    def delete(self, uuid: UUID) -> None:
+        self.session.delete(f"{self.api_url}/v1/workspace-documents/{uuid}/")
+
+    @classmethod
+    def _build_workspace_document(cls, response: Response) -> WorkspaceDocument:
+        response_json = response.json()
+        instance_data = response_json.get('data', {})
+        return WorkspaceDocument.from_dict(camel_to_snake(instance_data))

documente_shared-0.1.161/documente_shared/infrastructure/repositories/http_workspace_document_page.py

@@ -0,0 +1,71 @@
+from dataclasses import dataclass
+from typing import Any, List, Optional
+from uuid import UUID
+
+from loguru import logger
+from requests import Response
+
+from documente_shared.application.payloads import camel_to_snake
+from documente_shared.domain.entities.workspace_document_page import WorkspaceDocumentPage
+from documente_shared.domain.entities.workspace_document_page_filters import WorkspaceDocumentPageFilters
+from documente_shared.domain.repositories.workspace_document_page import WorkspaceDocumentPageRepository
+from documente_shared.infrastructure.documente_client import DocumenteClientMixin
+
+
+@dataclass
+class HttpWorkspaceDocumentPageRepository(
+    DocumenteClientMixin,
+    WorkspaceDocumentPageRepository,
+):
+    def find(self, uuid: UUID) -> Optional[WorkspaceDocumentPage]:
+        response = self.session.get(
+            url=f"{self.api_url}/v1/workspace-document-pages/{uuid}/",
+        )
+        if response.status_code not in [200, 201]:
+            return None
+        return self._build_workspace_document_page(response)
+
+    def filter(self, filters: WorkspaceDocumentPageFilters) -> List[WorkspaceDocumentPage]:
+        response = self.session.get(
+            url=f"{self.api_url}/v1/workspace-documents/{filters.workspace_document_id}/pages/",
+            params=filters.to_params,
+        )
+        if response.status_code not in [200, 201]:
+            return []
+        raw_response = response.json()
+        return [
+            WorkspaceDocumentPage.from_dict(camel_to_snake(item_data))
+            for item_data in raw_response.get('data', [])
+        ]
+
+    def filter_paginated(self, filters: WorkspaceDocumentPageFilters, page_params: Any) -> Any:
+        params = {**filters.to_params}
+        if isinstance(page_params, dict):
+            params.update(page_params)
+        response = self.session.get(
+            url=f"{self.api_url}/v1/workspace-documents/{filters.workspace_document_id}/pages/",
+            params=params,
+        )
+        if response.status_code not in [200, 201]:
+            return {"data": [], "count": 0}
+        return response.json()
+
+    def persist(self, instance: WorkspaceDocumentPage) -> WorkspaceDocumentPage:
+        logger.info(f"PERSISTING_WORKSPACE_DOCUMENT_PAGE: data={instance.to_persist_dict}")
+        response: Response = self.session.post(
+            url=f"{self.api_url}/v1/workspace-documents/{instance.workspace_document_id}/pages/",
+            json=instance.to_persist_dict,
+        )
+        if response.status_code not in [200, 201]:
+            logger.info(f"PERSISTING_WORKSPACE_DOCUMENT_PAGE ERROR: data={response.text}")
+            return instance
+        return self._build_workspace_document_page(response)
+
+    def delete(self, uuid: UUID) -> None:
+        self.session.delete(f"{self.api_url}/v1/workspace-document-pages/{uuid}/")
+
+    @classmethod
+    def _build_workspace_document_page(cls, response: Response) -> WorkspaceDocumentPage:
+        response_json = response.json()
+        instance_data = response_json.get('data', {})
+        return WorkspaceDocumentPage.from_dict(camel_to_snake(instance_data))

{documente_shared-0.1.159 → documente_shared-0.1.161}/pyproject.toml

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

{documente_shared-0.1.159 → documente_shared-0.1.161}/uv.lock

@@ -129,7 +129,7 @@ wheels = [
 
 [[package]]
 name = "documente-shared"
-version = "0.1.159"
+version = "0.1.161"
 source = { editable = "." }
 dependencies = [
     { name = "boto3" },