documente_shared 0.1.160__tar.gz → 0.1.161b1__tar.gz

{documente_shared-0.1.160 → documente_shared-0.1.161b1}/PKG-INFO

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

documente_shared-0.1.161b1/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_id: UUID
+    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_id": str(self.tenant_id),
+            "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_id": str(self.tenant_id),
+            "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_id=data.get('tenant_id'),
+            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.161b1/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_id: UUID
+    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_id": str(self.tenant_id),
+            "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_id": str(self.tenant_id),
+            "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_id=data.get('tenant_id'),
+            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.161b1/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_id: UUID
+    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_id": str(self.tenant_id),
+            "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_id": str(self.tenant_id),
+            "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_id=data.get('tenant_id'),
+            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.161b1/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.161b1/documente_shared/domain/repositories/workspace.py

@@ -0,0 +1,31 @@
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+from uuid import UUID
+
+from documente_shared.domain.entities.workspace import Workspace
+
+
+class WorkspaceRepository(ABC):
+    @abstractmethod
+    def find(self, uuid: UUID) -> Optional[Workspace]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def find_by_tenant(self, tenant_id: UUID, include_archived: bool = False) -> list[Workspace]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def filter(self, tenant_id: UUID) -> list[Workspace]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def filter_paginated(self, tenant_id: UUID, 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.161b1/documente_shared/domain/repositories/workspace_document.py

@@ -0,0 +1,42 @@
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+from uuid import UUID
+
+from documente_shared.domain.entities.workspace_document import WorkspaceDocument
+from documente_shared.domain.enums.common import ProcessingStatus
+
+
+class WorkspaceDocumentRepository(ABC):
+    @abstractmethod
+    def find(self, uuid: UUID) -> Optional[WorkspaceDocument]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def find_by_digest(self, workspace_id: UUID, digest: str) -> Optional[WorkspaceDocument]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def filter_by_workspace(
+        self,
+        workspace_id: UUID,
+        status: Optional[ProcessingStatus] = None,
+        limit: Optional[int] = None,
+        offset: int = 0,
+    ) -> list[WorkspaceDocument]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def filter(self, workspace_id: UUID) -> list[WorkspaceDocument]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def filter_paginated(self, workspace_id: UUID, 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.161b1/documente_shared/domain/repositories/workspace_document_page.py

@@ -0,0 +1,41 @@
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+from uuid import UUID
+
+from documente_shared.domain.entities.workspace_document_page import WorkspaceDocumentPage
+
+
+class WorkspaceDocumentPageRepository(ABC):
+    @abstractmethod
+    def find(self, uuid: UUID) -> Optional[WorkspaceDocumentPage]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def find_by_document(self, workspace_document_id: UUID) -> list[WorkspaceDocumentPage]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def find_by_document_and_page_number(
+        self, workspace_document_id: UUID, page_number: int
+    ) -> Optional[WorkspaceDocumentPage]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def filter(self, workspace_document_id: UUID) -> list[WorkspaceDocumentPage]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def filter_paginated(self, workspace_document_id: UUID, page_params: Any) -> Any:
+        raise NotImplementedError
+
+    @abstractmethod
+    def persist(self, instance: WorkspaceDocumentPage) -> WorkspaceDocumentPage:
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete(self, uuid: UUID) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete_by_document(self, workspace_document_id: UUID) -> None:
+        raise NotImplementedError

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

@@ -0,0 +1,89 @@
+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.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 find_by_tenant(
+        self,
+        tenant_id: UUID,
+        include_archived: bool = False,
+    ) -> List[Workspace]:
+        params = {}
+        if include_archived:
+            params["include_archived"] = "true"
+        response = self.session.get(
+            url=f"{self.api_url}/v1/workspaces/",
+            params=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(self, tenant_id: UUID) -> List[Workspace]:
+        response = self.session.get(
+            url=f"{self.api_url}/v1/workspaces/",
+        )
+        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, tenant_id: UUID, page_params: Any) -> Any:
+        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.161b1/documente_shared/infrastructure/repositories/http_workspace_document.py

@@ -0,0 +1,113 @@
+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.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 find_by_digest(
+        self,
+        workspace_id: UUID,
+        digest: str,
+    ) -> Optional[WorkspaceDocument]:
+        params = {"digest": digest}
+        response = self.session.get(
+            url=f"{self.api_url}/v1/workspaces/{workspace_id}/documents/",
+            params=params,
+        )
+        if response.status_code not in [200, 201]:
+            return None
+        raw_response = response.json()
+        results = raw_response.get('data', [])
+        if not results:
+            return None
+        return WorkspaceDocument.from_dict(camel_to_snake(results[0]))
+
+    def filter_by_workspace(
+        self,
+        workspace_id: UUID,
+        status: Optional[ProcessingStatus] = None,
+        limit: Optional[int] = None,
+        offset: int = 0,
+    ) -> List[WorkspaceDocument]:
+        params = {}
+        if status:
+            params["status"] = str(status)
+        if limit is not None:
+            params["limit"] = limit
+        if offset:
+            params["offset"] = offset
+        response = self.session.get(
+            url=f"{self.api_url}/v1/workspaces/{workspace_id}/documents/",
+            params=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(self, workspace_id: UUID) -> List[WorkspaceDocument]:
+        response = self.session.get(
+            url=f"{self.api_url}/v1/workspaces/{workspace_id}/documents/",
+        )
+        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, workspace_id: UUID, page_params: Any) -> Any:
+        params = {}
+        if isinstance(page_params, dict):
+            params.update(page_params)
+        response = self.session.get(
+            url=f"{self.api_url}/v1/workspaces/{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.161b1/documente_shared/infrastructure/repositories/http_workspace_document_page.py

@@ -0,0 +1,107 @@
+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.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 find_by_document(
+        self,
+        workspace_document_id: UUID,
+    ) -> List[WorkspaceDocumentPage]:
+        response = self.session.get(
+            url=f"{self.api_url}/v1/workspace-documents/{workspace_document_id}/pages/",
+        )
+        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 find_by_document_and_page_number(
+        self,
+        workspace_document_id: UUID,
+        page_number: int,
+    ) -> Optional[WorkspaceDocumentPage]:
+        params = {"page_number": page_number}
+        response = self.session.get(
+            url=f"{self.api_url}/v1/workspace-documents/{workspace_document_id}/pages/",
+            params=params,
+        )
+        if response.status_code not in [200, 201]:
+            return None
+        raw_response = response.json()
+        results = raw_response.get('data', [])
+        if not results:
+            return None
+        return WorkspaceDocumentPage.from_dict(camel_to_snake(results[0]))
+
+    def filter(self, workspace_document_id: UUID) -> List[WorkspaceDocumentPage]:
+        response = self.session.get(
+            url=f"{self.api_url}/v1/workspace-documents/{workspace_document_id}/pages/",
+        )
+        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, workspace_document_id: UUID, page_params: Any) -> Any:
+        params = {}
+        if isinstance(page_params, dict):
+            params.update(page_params)
+        response = self.session.get(
+            url=f"{self.api_url}/v1/workspace-documents/{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}/")
+
+    def delete_by_document(self, workspace_document_id: UUID) -> None:
+        pages = self.find_by_document(workspace_document_id)
+        for page in pages:
+            self.delete(page.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.160 → documente_shared-0.1.161b1}/pyproject.toml

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

{documente_shared-0.1.160 → documente_shared-0.1.161b1}/uv.lock

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