documente_shared 0.1.79__tar.gz → 0.1.80__tar.gz

{documente_shared-0.1.79 → documente_shared-0.1.80}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: documente_shared
-Version: 0.1.79
+Version: 0.1.80
 Summary: Shared utilities for Documente AI projects
 License: MIT
 Author: Tech

{documente_shared-0.1.79 → documente_shared-0.1.80}/documente_shared/domain/entities/processing_case_item.py

@@ -135,12 +135,24 @@ class ProcessingCaseItem(object):
                 str(self.processing_confidence.quantize(Decimal('0.001')))
                 if self.processing_confidence else None
             ),
-            'uploaded_at': self.uploaded_at.isoformat() if self.uploaded_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,
+            'uploaded_at': (
+                self.uploaded_at.isoformat()
+                if self.uploaded_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
+            ),
             'feedback': self.feedback,
             'metadata': self.metadata,
-            'completed_at': self.completed_at.isoformat() if self.completed_at else None,
+            'completed_at': (
+                self.completed_at.isoformat()
+                if self.completed_at else None
+            ),
         }
 
     @property
@@ -148,6 +160,15 @@ class ProcessingCaseItem(object):
         simple_dict = self.to_dict.copy()
         return simple_dict
 
+    @property
+    def to_persist_dict(self) -> dict:
+        simple_dict = self.to_dict.copy()
+        simple_dict["document_path"] = self.document.file_path if self.document else None
+        simple_dict["processed_csv_path"] = self.processed_csv.file_path if self.processed_csv else None
+        simple_dict["processed_xlsx_path"] = self.processed_xlsx.file_path if self.processed_xlsx else None
+        simple_dict["processed_json_path"] = self.processed_json.file_path if self.processed_json else None
+        return simple_dict
+
     def overload(
         self,
         new_instance: 'ProcessingCaseItem',
@@ -220,3 +241,16 @@ class ProcessingCaseItem(object):
             metadata=data.get('metadata', {}),
             completed_at=get_datetime_from_data(input_datetime=data.get('completed_at')),
         )
+
+    @classmethod
+    def from_persist_dict(cls, data: dict) -> 'ProcessingCaseItem':
+        instance = cls.from_dict(data)
+        if "document_path" in data:
+            instance.document = InMemoryDocument(file_path=data["document_path"])
+        if "processed_csv_path" in data:
+            instance.processed_csv = InMemoryDocument(file_path=data["processed_csv_path"])
+        if "processed_xlsx_path" in data:
+            instance.processed_xlsx = InMemoryDocument(file_path=data["processed_xlsx_path"])
+        if "processed_json_path" in data:
+            instance.processed_json = InMemoryDocument(file_path=data["processed_json_path"])
+        return instance

{documente_shared-0.1.79 → documente_shared-0.1.80}/documente_shared/domain/repositories/processing_case.py

@@ -8,7 +8,7 @@ from documente_shared.domain.entities.processing_case_filters import ProcessingC
 class ProcessingCaseRepository(ABC):
 
     @abstractmethod
-    def find(self, uuid: str) -> Optional[ProcessingCase]:
+    def find(self, uuid: str, include_items: bool = False) -> Optional[ProcessingCase]:
         raise NotImplementedError
 
     @abstractmethod

{documente_shared-0.1.79 → documente_shared-0.1.80}/documente_shared/infrastructure/repositories/dynamo_processing_case.py

@@ -3,7 +3,7 @@ from typing import Optional, List
 from boto3.dynamodb.conditions import Key
 
 from documente_shared.domain.entities.processing_case import ProcessingCase
-from documente_shared.domain.enums.common import ProcessingStatus
+from documente_shared.domain.entities.processing_case_filters import ProcessingCaseFilters
 from documente_shared.domain.repositories.processing_case import ProcessingCaseRepository
 
 from documente_shared.infrastructure.dynamo_table import DynamoDBTable
@@ -13,7 +13,7 @@ class DynamoProcessingCaseRepository(
     DynamoDBTable,
     ProcessingCaseRepository,
 ):
-    def find(self, uuid: str) -> Optional[ProcessingCase]:
+    def find(self, uuid: str, include_items: bool = False) -> Optional[ProcessingCase]:
         item = self.get(key={'uuid': uuid})
         if item:
             return ProcessingCase.from_dict(item)
@@ -26,10 +26,10 @@ class DynamoProcessingCaseRepository(
     def remove(self, instance: ProcessingCase):
         self.delete(key={'uuid': instance.uuid})
 
-    def filter(self, statuses: List[ProcessingStatus]) -> List[ProcessingCase]:
+    def filter(self, tenant_slug: str, filters: ProcessingCaseFilters) -> List[ProcessingCase]:
         items = []
 
-        for status in statuses:
+        for status in filters.statuses:
             response = self._table.query(
                 IndexName='status',
                 KeyConditionExpression=Key('status').eq(status.value),

{documente_shared-0.1.79 → documente_shared-0.1.80}/documente_shared/infrastructure/repositories/http_processing_case.py

@@ -12,15 +12,15 @@ class HttpProcessingCaseRepository(
     DocumenteClientMixin,
     ProcessingCaseRepository,
 ):
-    def find(self, uuid: str) -> Optional[ProcessingCase]:
-        response = self.session.get(f"{self.api_url}/processing-cases/{uuid}/")
+    def find(self, uuid: str, include_items: bool = False) -> Optional[ProcessingCase]:
+        response = self.session.get(f"{self.api_url}/v1/processing-cases/{uuid}/")
         if response.status_code == 200:
             return ProcessingCase.from_dict(response.json())
         return None
 
     def persist(self, instance: ProcessingCase) -> ProcessingCase:
         response = self.session.put(
-            url=f"{self.api_url}/processing-cases/{instance.uuid}/",
+            url=f"{self.api_url}/v1/processing-cases/{instance.uuid}/",
             json=instance.to_dict,
         )
         if response.status_code not in [200, 201]:
@@ -28,10 +28,15 @@ class HttpProcessingCaseRepository(
         return ProcessingCase.from_dict(response.json())
 
     def remove(self, instance: ProcessingCase):
-        self.session.delete(f"{self.api_url}/processing-cases/{instance.uuid}/")
+        self.session.delete(f"{self.api_url}/v1/processing-cases/{instance.uuid}/")
 
     def filter(self, tenant_slug: str, filters: ProcessingCaseFilters) -> List[ProcessingCase]:
-        response = self.session.get(f"{self.api_url}/processing-cases/")
+        response = self.session.get(
+            url=f"{self.api_url}/v1/processing-cases/",
+            headers={
+                "X-Tenant": tenant_slug,
+            }
+        )
         if response.status_code == 200:
             raw_response = response.json()
             return [

{documente_shared-0.1.79 → documente_shared-0.1.80}/documente_shared/infrastructure/repositories/http_processing_case_item.py

@@ -16,19 +16,19 @@ class HttpProcessingCaseItemRepository(
     def find(self, uuid: str) -> Optional[ProcessingCaseItem]:
         response = self.session.get(f"{self.api_url}/processing-case-items/{uuid}/")
         if response.status_code == 200:
-            return ProcessingCaseItem.from_dict(response.json())
+            return ProcessingCaseItem.from_persist_dict(response.json())
         return None
 
     def find_by_digest(self, digest: str) -> Optional[ProcessingCaseItem]:
         response = self.session.get(f"{self.api_url}/processing-case-items/{digest}/")
         if response.status_code == 200:
-            return ProcessingCaseItem.from_dict(response.json())
+            return ProcessingCaseItem.from_persist_dict(response.json())
         return None
 
     def persist(self, instance: ProcessingCaseItem) -> ProcessingCaseItem:
         response = self.session.put(
             url=f"{self.api_url}/processing-case-items/{instance.uuid}/",
-            json=instance.to_simple_dict,
+            json=instance.to_persist_dict,
         )
         if response.status_code in [200, 201]:
             return ProcessingCaseItem.from_dict(response.json())
@@ -46,7 +46,7 @@ class HttpProcessingCaseItemRepository(
         if response.status_code == 200:
             raw_response = response.json()
             return [
-                ProcessingCaseItem.from_dict(item)
+                ProcessingCaseItem.from_persist_dict(item)
                 for item in raw_response.get('data', [])
             ]
         return []

{documente_shared-0.1.79 → documente_shared-0.1.80}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "documente_shared"
-version = "0.1.79"
+version = "0.1.80"
 description = "Shared utilities for Documente AI projects"
 authors = ["Tech <tech@llamitai.com>"]
 license = "MIT"