documente_shared 0.1.71__py3-none-any.whl → 0.1.72b0__py3-none-any.whl

documente_shared/domain/entities/document_metadata.py

@@ -1,64 +1,64 @@
-from dataclasses import dataclass
-from datetime import datetime
-from typing import Optional
-
-
-@dataclass
-class DocumentProcessingMetadata(object):
-    publication_date: Optional[datetime] = None
-    num_circular: Optional[str] = None
-    asfi_identifier: Optional[str] = None
-    contains_tables: Optional[bool] = None
-    text_content: Optional[str] = None
-    case_name: Optional[str] = None
-    starting_office: Optional[str] = None
-    output_json: Optional[dict] = None
-    processing_time: Optional[float] = None
-    llm_model: Optional[str] = None
-    num_pages: Optional[float] = None
-    num_tokens: Optional[float] = None
-    citcular_type: Optional[str] = None
-
-    @property
-    def to_dict(self):
-        return {
-            'publication_date': (
-                self.publication_date.isoformat()
-                if self.publication_date
-                else None
-            ),
-            'num_circular': self.num_circular,
-            'asfi_identifier': self.asfi_identifier,
-            'contains_tables': self.contains_tables,
-            'text_content': self.text_content,
-            'case_name': self.case_name,
-            'starting_office': self.starting_office,
-            'output_json': self.output_json,
-            'processing_time': self.processing_time,
-            'llm_model': self.llm_model,
-            'num_pages': self.num_pages,
-            'num_tokens': self.num_tokens,
-            'citcular_type': self.citcular_type
-        }
-
-    @classmethod
-    def from_dict(cls, data: dict):
-        return cls(
-            publication_date=(
-                datetime.fromisoformat(data.get('publication_date'))
-                if data.get('publication_date')
-                else None
-            ),
-            num_circular=data.get('num_circular'),
-            asfi_identifier=data.get('asfi_identifier'),
-            contains_tables=data.get('contains_tables'),
-            text_content=data.get('text_content'),
-            case_name=data.get('case_name'),
-            starting_office=data.get('starting_office'),
-            output_json=data.get('output_json'),
-            processing_time=data.get('processing_time'),
-            llm_model=data.get('llm_model'),
-            num_pages=data.get('num_pages'),
-            num_tokens=data.get('num_tokens'),
-            citcular_type=data.get('citcular_type')
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional
+
+
+@dataclass
+class DocumentProcessingMetadata(object):
+    publication_date: Optional[datetime] = None
+    num_circular: Optional[str] = None
+    asfi_identifier: Optional[str] = None
+    contains_tables: Optional[bool] = None
+    text_content: Optional[str] = None
+    case_name: Optional[str] = None
+    starting_office: Optional[str] = None
+    output_json: Optional[dict] = None
+    processing_time: Optional[float] = None
+    llm_model: Optional[str] = None
+    num_pages: Optional[float] = None
+    num_tokens: Optional[float] = None
+    citcular_type: Optional[str] = None
+
+    @property
+    def to_dict(self):
+        return {
+            'publication_date': (
+                self.publication_date.isoformat()
+                if self.publication_date
+                else None
+            ),
+            'num_circular': self.num_circular,
+            'asfi_identifier': self.asfi_identifier,
+            'contains_tables': self.contains_tables,
+            'text_content': self.text_content,
+            'case_name': self.case_name,
+            'starting_office': self.starting_office,
+            'output_json': self.output_json,
+            'processing_time': self.processing_time,
+            'llm_model': self.llm_model,
+            'num_pages': self.num_pages,
+            'num_tokens': self.num_tokens,
+            'citcular_type': self.citcular_type
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(
+            publication_date=(
+                datetime.fromisoformat(data.get('publication_date'))
+                if data.get('publication_date')
+                else None
+            ),
+            num_circular=data.get('num_circular'),
+            asfi_identifier=data.get('asfi_identifier'),
+            contains_tables=data.get('contains_tables'),
+            text_content=data.get('text_content'),
+            case_name=data.get('case_name'),
+            starting_office=data.get('starting_office'),
+            output_json=data.get('output_json'),
+            processing_time=data.get('processing_time'),
+            llm_model=data.get('llm_model'),
+            num_pages=data.get('num_pages'),
+            num_tokens=data.get('num_tokens'),
+            citcular_type=data.get('citcular_type')
         )

documente_shared/domain/entities/in_memory_result.py

@@ -1,51 +1,51 @@
-from dataclasses import dataclass
-from typing import Optional
-
-from documente_shared.application.files import (
-    remove_slash_from_path,
-    get_filename_from_path,
-)
-
-
-@dataclass
-class InMemoryDocument(object):
-    file_path: Optional[str] = None
-    file_bytes: Optional[bytes] = None
-
-    @property
-    def is_valid(self) -> bool:
-        return bool(self.file_path) and self.file_bytes
-
-    @property
-    def has_content(self) -> bool:
-        return bool(self.file_bytes)
-
-    @property
-    def file_key(self) -> Optional[str]:
-        if not self.file_path:
-            return None
-        return remove_slash_from_path(self.file_path)
-
-    @property
-    def file_name(self) -> Optional[str]:
-        if not self.file_path:
-            return None
-        return get_filename_from_path(self.file_path)
-
-    @property
-    def is_procesable(self) -> bool:
-        return self.is_valid and self.has_content
-
-    @property
-    def to_dict(self) -> dict:
-        return {
-            'file_path': self.file_path,
-            'file_bytes': self.file_bytes,
-        }
-
-    @classmethod
-    def from_dict(cls, data: dict):
-        return cls(
-            file_path=data.get('file_path'),
-            file_bytes=data.get('file_bytes'),
-        )
+from dataclasses import dataclass
+from typing import Optional
+
+from documente_shared.application.files import (
+    remove_slash_from_path,
+    get_filename_from_path,
+)
+
+
+@dataclass
+class InMemoryDocument(object):
+    file_path: Optional[str] = None
+    file_bytes: Optional[bytes] = None
+
+    @property
+    def is_valid(self) -> bool:
+        return bool(self.file_path) and self.file_bytes
+
+    @property
+    def has_content(self) -> bool:
+        return bool(self.file_bytes)
+
+    @property
+    def file_key(self) -> Optional[str]:
+        if not self.file_path:
+            return None
+        return remove_slash_from_path(self.file_path)
+
+    @property
+    def file_name(self) -> Optional[str]:
+        if not self.file_path:
+            return None
+        return get_filename_from_path(self.file_path)
+
+    @property
+    def is_procesable(self) -> bool:
+        return self.is_valid and self.has_content
+
+    @property
+    def to_dict(self) -> dict:
+        return {
+            'file_path': self.file_path,
+            'file_bytes': self.file_bytes,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(
+            file_path=data.get('file_path'),
+            file_bytes=data.get('file_bytes'),
+        )

documente_shared/domain/entities/processing_case.py

@@ -1,139 +1,144 @@
-from dataclasses import dataclass
-from datetime import datetime, tzinfo
-from typing import Optional, List
-
-from documente_shared.application.time_utils import get_datetime_from_data
-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 ProcessingCaseCategory
-
-
-@dataclass
-class ProcessingCase(object):
-    case_id: str
-    status: ProcessingStatus
-    category: Optional[ProcessingCaseCategory] = None
-    enqueued_at: Optional[datetime] = None
-    started_at: Optional[datetime] = None
-    failed_at: Optional[datetime] = None
-    feedback: Optional[list | dict] = None
-    completed_at: Optional[datetime] = None
-    metadata: Optional[dict] = None
-    items: Optional[List[ProcessingCaseItem]] = None
-
-    def __post_init__(self):
-        self.items = self.items or []
-
-    @property
-    def is_procesable(self) -> bool:
-        return self.items and len(self.items) > 0
-
-    def pending(self, timezone: tzinfo = la_paz_tz):
-        self.status = ProcessingStatus.PENDING
-        self.started_at = None
-
-    def enqueue(self, timezone: tzinfo = la_paz_tz):
-        self.status = ProcessingStatus.ENQUEUED
-        self.enqueued_at = datetime.now(tz=timezone)
-
-    def processing(self, timezone: tzinfo = la_paz_tz):
-        self.status = ProcessingStatus.PROCESSING
-        self.started_at = datetime.now(tz=timezone)
-
-    def failed(
-        self,
-        error_message: Optional[str] = None,
-        timezone: tzinfo = la_paz_tz,
-    ):
-        self.status = ProcessingStatus.FAILED
-        self.failed_at = datetime.now(tz=timezone)
-
-    def completed(self, timezone: tzinfo = la_paz_tz):
-        self.status = ProcessingStatus.COMPLETED
-        self.completed_at = datetime.now(tz=timezone)
-
-    def deleted(self):
-        self.status = ProcessingStatus.DELETED
-    
-    def __eq__(self, other: 'ProcessingCase') -> bool:
-        if not other:
-            return False
-
-        return (
-                self.case_id == other.case_id
-                and self.status == other.status
-                and self.category == other.category
-                and self.enqueued_at == other.enqueued_at
-                and self.started_at == other.started_at
-                and self.failed_at == other.failed_at
-                and self.feedback == other.feedback
-                and self.completed_at == other.completed_at
-                and self.metadata == other.metadata
-        )
-
-    @property
-    def to_dict(self) -> dict:
-        return {
-            'case_id': self.case_id,
-            'status': str(self.status),
-            'category': (
-                str(self.category)
-                if self.category 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,
-            'feedback': self.feedback,
-            'completed_at': self.completed_at.isoformat() if self.completed_at else None,
-            'metadata': self.metadata,
-            'items': [item.to_dict for item in self.items],
-        }
-
-    @property
-    def to_persist_dict(self) -> dict:
-        return self.to_dict
-
-    def overload(
-        self,
-        new_instance: 'ProcessingCase',
-        properties: List[str] = None,
-    ):
-        instance_properties = properties or [
-            'status',
-            'category',
-            'enqueued_at',
-            'started_at',
-            'failed_at',
-            'feedback',
-            'completed_at',
-            'metadata',
-            'items',
-        ]
-        for _property in instance_properties:
-            property_value = getattr(new_instance, _property)
-            if not hasattr(self, _property):
-                continue
-            setattr(self, _property, property_value)
-        return self
-
-    @classmethod
-    def from_dict(cls, data: dict) -> 'ProcessingCase':
-        return cls(
-            case_id=data.get('case_id'),
-            status=ProcessingStatus.from_value(data.get('status')),
-            category=(
-                ProcessingCaseCategory.from_value(data.get('category'))
-                if data.get('category') else None
-            ),
-            enqueued_at=get_datetime_from_data(input_datetime=data.get('enqueued_at')),
-            started_at=get_datetime_from_data(input_datetime=data.get('started_at')),
-            failed_at=get_datetime_from_data(input_datetime=data.get('failed_at')),
-            feedback=data.get('feedback'),
-            metadata=data.get('metadata', {}),
-            completed_at=get_datetime_from_data(input_datetime=data.get('completed_at')),
-            items=[
-                ProcessingCaseItem.from_dict(item_dict)
-                for item_dict in data.get('items', [])
-            ],
-        )
+from dataclasses import dataclass
+from datetime import datetime, tzinfo
+from typing import Optional, List
+
+from documente_shared.application.time_utils import get_datetime_from_data
+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 ProcessingCaseCategory
+
+
+@dataclass
+class ProcessingCase(object):
+    uuid: str
+    label: str
+    status: ProcessingStatus
+    category: Optional[ProcessingCaseCategory] = None
+    enqueued_at: Optional[datetime] = None
+    started_at: Optional[datetime] = None
+    failed_at: Optional[datetime] = None
+    feedback: Optional[list | dict] = None
+    completed_at: Optional[datetime] = None
+    metadata: Optional[dict] = None
+    items: Optional[List[ProcessingCaseItem]] = None
+
+    def __post_init__(self):
+        self.items = self.items or []
+
+    @property
+    def is_procesable(self) -> bool:
+        return self.items and len(self.items) > 0
+
+    def pending(self, timezone: tzinfo = la_paz_tz):
+        self.status = ProcessingStatus.PENDING
+        self.started_at = None
+
+    def enqueue(self, timezone: tzinfo = la_paz_tz):
+        self.status = ProcessingStatus.ENQUEUED
+        self.enqueued_at = datetime.now(tz=timezone)
+
+    def processing(self, timezone: tzinfo = la_paz_tz):
+        self.status = ProcessingStatus.PROCESSING
+        self.started_at = datetime.now(tz=timezone)
+
+    def failed(
+        self,
+        error_message: Optional[str] = None,
+        timezone: tzinfo = la_paz_tz,
+    ):
+        self.status = ProcessingStatus.FAILED
+        self.failed_at = datetime.now(tz=timezone)
+
+    def completed(self, timezone: tzinfo = la_paz_tz):
+        self.status = ProcessingStatus.COMPLETED
+        self.completed_at = datetime.now(tz=timezone)
+
+    def deleted(self):
+        self.status = ProcessingStatus.DELETED
+    
+    def __eq__(self, other: 'ProcessingCase') -> bool:
+        if not other:
+            return False
+
+        return (
+                self.uuid == other.uuid
+                and self.label == other.label
+                and self.status == other.status
+                and self.category == other.category
+                and self.enqueued_at == other.enqueued_at
+                and self.started_at == other.started_at
+                and self.failed_at == other.failed_at
+                and self.feedback == other.feedback
+                and self.completed_at == other.completed_at
+                and self.metadata == other.metadata
+        )
+
+    @property
+    def to_dict(self) -> dict:
+        return {
+            'uuid': self.uuid,
+            'label': self.label,
+            'status': str(self.status),
+            'category': (
+                str(self.category)
+                if self.category 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,
+            'feedback': self.feedback,
+            'completed_at': self.completed_at.isoformat() if self.completed_at else None,
+            'metadata': self.metadata,
+            'items': [item.to_dict for item in self.items],
+        }
+
+    @property
+    def to_persist_dict(self) -> dict:
+        return self.to_dict
+
+    def overload(
+        self,
+        new_instance: 'ProcessingCase',
+        properties: List[str] = None,
+    ):
+        instance_properties = properties or [
+            'label',
+            'status',
+            'category',
+            'enqueued_at',
+            'started_at',
+            'failed_at',
+            'feedback',
+            'completed_at',
+            'metadata',
+            'items',
+        ]
+        for _property in instance_properties:
+            property_value = getattr(new_instance, _property)
+            if not hasattr(self, _property):
+                continue
+            setattr(self, _property, property_value)
+        return self
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'ProcessingCase':
+        return cls(
+            uuid=data.get('uuid'),
+            label=data.get('label'),
+            status=ProcessingStatus.from_value(data.get('status')),
+            category=(
+                ProcessingCaseCategory.from_value(data.get('category'))
+                if data.get('category') else None
+            ),
+            enqueued_at=get_datetime_from_data(input_datetime=data.get('enqueued_at')),
+            started_at=get_datetime_from_data(input_datetime=data.get('started_at')),
+            failed_at=get_datetime_from_data(input_datetime=data.get('failed_at')),
+            feedback=data.get('feedback'),
+            metadata=data.get('metadata', {}),
+            completed_at=get_datetime_from_data(input_datetime=data.get('completed_at')),
+            items=[
+                ProcessingCaseItem.from_dict(item_dict)
+                for item_dict in data.get('items', [])
+            ],
+        )