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

documente_shared/domain/entities/processing_case_item.py

@@ -1,216 +1,216 @@
-from dataclasses import dataclass
-from datetime import datetime, tzinfo
-from decimal import Decimal
-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.in_memory_result import InMemoryDocument
-from documente_shared.domain.enums.common import ProcessingStatus, ProcessingSource
-from documente_shared.domain.enums.processing_case import ProcessingDocumentType
-
-
-@dataclass
-class ProcessingCaseItem(object):
-    uuid: str
-    case_id: str
-    digest: str
-    status: ProcessingStatus
-    document_type: ProcessingDocumentType
-    document: InMemoryDocument
-    uploaded_from: Optional[ProcessingSource] = None
-    processed_csv: Optional[InMemoryDocument] = None
-    processed_xlsx: Optional[InMemoryDocument] = None
-    processed_json: Optional[InMemoryDocument] = None
-    processing_time: Optional[Decimal] = None
-    processing_confidence: Optional[Decimal] = None
-    uploaded_at: Optional[datetime] = None
-    started_at: Optional[datetime] = None
-    failed_at: Optional[datetime] = None
-    completed_at: Optional[datetime] = None
-    feedback: Optional[list | dict] = None
-    metadata: Optional[dict] = None
-
-    def __post_init__(self):
-        self.feedback = self.feedback or []
-        self.metadata = self.metadata or {}
-    
-    @property
-    def is_procesable(self) -> bool:
-        return (
-            (self.status.is_pending or self.status.is_enqueued)
-            and self.digest
-            and self.document
-            and self.document.is_procesable
-        )
-
-    @property
-    def is_finished(self) -> bool:
-        return self.status in [
-            ProcessingStatus.COMPLETED,
-            ProcessingStatus.FAILED,
-        ]
-
-    def pending(self, timezone: tzinfo = la_paz_tz):
-        self.status = ProcessingStatus.PENDING
-        self.started_at = None
-
-    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 incomplete(self, timezone: tzinfo = la_paz_tz):
-        self.status = ProcessingStatus.INCOMPLETE
-        self.completed_at = datetime.now(tz=timezone)
-
-    def deleted(self):
-        self.status = ProcessingStatus.DELETED
-    
-    def in_review(self):
-        self.status = ProcessingStatus.IN_REVIEW
-
-    def __eq__(self, other: 'ProcessingCaseItem') -> bool:
-        if not other:
-            return False
-
-        return (
-            self.uuid == other.uuid
-            and self.digest == other.digest
-            and self.status == other.status
-            and self.document_type == other.document_type
-            and self.document == other.document
-            and self.processing_time == other.processing_time
-            and self.processing_confidence == other.processing_confidence
-            and self.uploaded_at == other.uploaded_at
-            and self.started_at == other.started_at
-            and self.failed_at == other.failed_at
-            and self.completed_at == other.completed_at
-        )
-
-    @property
-    def to_dict(self) -> dict:
-        return {
-            'uuid': self.uuid,
-            'case_id': self.case_id,
-            'digest': self.digest,
-            'status': str(self.status),
-            'document': self.document.to_dict,
-            'document_type': str(self.document_type),
-            'uploaded_from': (
-                str(self.uploaded_from)
-                if self.uploaded_from else None
-            ),
-            'processed_csv': (
-                self.processed_csv.to_dict
-                if self.processed_csv else None
-            ),
-            'processed_xlsx': (
-                self.processed_xlsx.to_dict
-                if self.processed_xlsx else None
-            ),
-            'processed_json': (
-                self.processed_json.to_dict
-                if self.processed_json else None
-            ),
-            'processing_time': (
-                str(self.processing_time.quantize(Decimal('0.001')))
-                if self.processing_time else None
-            ),
-            'processing_confidence': (
-                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,
-            'feedback': self.feedback,
-            'metadata': self.metadata,
-            'completed_at': self.completed_at.isoformat() if self.completed_at else None,
-        }
-
-    @property
-    def to_simple_dict(self) -> dict:
-        simple_dict = self.to_dict.copy()
-        return simple_dict
-
-    def overload(
-        self,
-        new_instance: 'ProcessingCaseItem',
-        properties: List[str] = None,
-    ):
-        instance_properties = properties or [
-            'status',
-            'document_type',
-            'document',
-            'uploaded_from',
-            'processed_csv',
-            'processed_xlsx',
-            'processed_json',
-            'processing_time',
-            'processing_confidence',
-            'uploaded_at',
-            'started_at',
-            'failed_at',
-            'completed_at',
-            'feedback',
-            'metadata',
-        ]
-        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) -> 'ProcessingCaseItem':
-        return cls(
-            uuid=data.get('uuid'),
-            case_id=data.get('case_id'),
-            digest=data.get('digest'),
-            status=ProcessingStatus.from_value(data.get('status')),
-            document=InMemoryDocument.from_dict(data.get('document')),
-            document_type=ProcessingDocumentType.from_value(data.get('document_type')),
-            uploaded_from=(
-                ProcessingSource.from_value(data.get('uploaded_from'))
-                if data.get('uploaded_from') else None
-            ),
-            processed_csv=(
-                InMemoryDocument.from_dict(data.get('processed_csv'))
-                if data.get('processed_csv') else None
-            ),
-            processed_xlsx=(
-                InMemoryDocument.from_dict(data.get('processed_xlsx'))
-                if data.get('processed_xlsx') else None
-            ),
-            processed_json=(
-                InMemoryDocument.from_dict(data.get('processed_json'))
-                if data.get('processed_json') else None
-            ),
-            processing_time=(
-                Decimal(data.get('processing_time'))
-                if data.get('processing_time') else None
-            ),
-            processing_confidence=(
-                Decimal(data.get('processing_confidence'))
-                if data.get('processing_confidence') else None
-            ),
-            uploaded_at=get_datetime_from_data(input_datetime=data.get('uploaded_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')),
-        )
+from dataclasses import dataclass
+from datetime import datetime, tzinfo
+from decimal import Decimal
+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.in_memory_result import InMemoryDocument
+from documente_shared.domain.enums.common import ProcessingStatus, ProcessingSource
+from documente_shared.domain.enums.processing_case import ProcessingDocumentType
+
+
+@dataclass
+class ProcessingCaseItem(object):
+    uuid: str
+    case_id: str
+    digest: str
+    status: ProcessingStatus
+    document_type: ProcessingDocumentType
+    document: InMemoryDocument
+    uploaded_from: Optional[ProcessingSource] = None
+    processed_csv: Optional[InMemoryDocument] = None
+    processed_xlsx: Optional[InMemoryDocument] = None
+    processed_json: Optional[InMemoryDocument] = None
+    processing_time: Optional[Decimal] = None
+    processing_confidence: Optional[Decimal] = None
+    uploaded_at: Optional[datetime] = None
+    started_at: Optional[datetime] = None
+    failed_at: Optional[datetime] = None
+    completed_at: Optional[datetime] = None
+    feedback: Optional[list | dict] = None
+    metadata: Optional[dict] = None
+
+    def __post_init__(self):
+        self.feedback = self.feedback or []
+        self.metadata = self.metadata or {}
+    
+    @property
+    def is_procesable(self) -> bool:
+        return (
+            (self.status.is_pending or self.status.is_enqueued)
+            and self.digest
+            and self.document
+            and self.document.is_procesable
+        )
+
+    @property
+    def is_finished(self) -> bool:
+        return self.status in [
+            ProcessingStatus.COMPLETED,
+            ProcessingStatus.FAILED,
+        ]
+
+    def pending(self, timezone: tzinfo = la_paz_tz):
+        self.status = ProcessingStatus.PENDING
+        self.started_at = None
+
+    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 incomplete(self, timezone: tzinfo = la_paz_tz):
+        self.status = ProcessingStatus.INCOMPLETE
+        self.completed_at = datetime.now(tz=timezone)
+
+    def deleted(self):
+        self.status = ProcessingStatus.DELETED
+    
+    def in_review(self):
+        self.status = ProcessingStatus.IN_REVIEW
+
+    def __eq__(self, other: 'ProcessingCaseItem') -> bool:
+        if not other:
+            return False
+
+        return (
+            self.uuid == other.uuid
+            and self.digest == other.digest
+            and self.status == other.status
+            and self.document_type == other.document_type
+            and self.document == other.document
+            and self.processing_time == other.processing_time
+            and self.processing_confidence == other.processing_confidence
+            and self.uploaded_at == other.uploaded_at
+            and self.started_at == other.started_at
+            and self.failed_at == other.failed_at
+            and self.completed_at == other.completed_at
+        )
+
+    @property
+    def to_dict(self) -> dict:
+        return {
+            'uuid': self.uuid,
+            'case_id': self.case_id,
+            'digest': self.digest,
+            'status': str(self.status),
+            'document': self.document.to_dict,
+            'document_type': str(self.document_type),
+            'uploaded_from': (
+                str(self.uploaded_from)
+                if self.uploaded_from else None
+            ),
+            'processed_csv': (
+                self.processed_csv.to_dict
+                if self.processed_csv else None
+            ),
+            'processed_xlsx': (
+                self.processed_xlsx.to_dict
+                if self.processed_xlsx else None
+            ),
+            'processed_json': (
+                self.processed_json.to_dict
+                if self.processed_json else None
+            ),
+            'processing_time': (
+                str(self.processing_time.quantize(Decimal('0.001')))
+                if self.processing_time else None
+            ),
+            'processing_confidence': (
+                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,
+            'feedback': self.feedback,
+            'metadata': self.metadata,
+            'completed_at': self.completed_at.isoformat() if self.completed_at else None,
+        }
+
+    @property
+    def to_simple_dict(self) -> dict:
+        simple_dict = self.to_dict.copy()
+        return simple_dict
+
+    def overload(
+        self,
+        new_instance: 'ProcessingCaseItem',
+        properties: List[str] = None,
+    ):
+        instance_properties = properties or [
+            'status',
+            'document_type',
+            'document',
+            'uploaded_from',
+            'processed_csv',
+            'processed_xlsx',
+            'processed_json',
+            'processing_time',
+            'processing_confidence',
+            'uploaded_at',
+            'started_at',
+            'failed_at',
+            'completed_at',
+            'feedback',
+            'metadata',
+        ]
+        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) -> 'ProcessingCaseItem':
+        return cls(
+            uuid=data.get('uuid'),
+            case_id=data.get('case_id'),
+            digest=data.get('digest'),
+            status=ProcessingStatus.from_value(data.get('status')),
+            document=InMemoryDocument.from_dict(data.get('document')),
+            document_type=ProcessingDocumentType.from_value(data.get('document_type')),
+            uploaded_from=(
+                ProcessingSource.from_value(data.get('uploaded_from'))
+                if data.get('uploaded_from') else None
+            ),
+            processed_csv=(
+                InMemoryDocument.from_dict(data.get('processed_csv'))
+                if data.get('processed_csv') else None
+            ),
+            processed_xlsx=(
+                InMemoryDocument.from_dict(data.get('processed_xlsx'))
+                if data.get('processed_xlsx') else None
+            ),
+            processed_json=(
+                InMemoryDocument.from_dict(data.get('processed_json'))
+                if data.get('processed_json') else None
+            ),
+            processing_time=(
+                Decimal(data.get('processing_time'))
+                if data.get('processing_time') else None
+            ),
+            processing_confidence=(
+                Decimal(data.get('processing_confidence'))
+                if data.get('processing_confidence') else None
+            ),
+            uploaded_at=get_datetime_from_data(input_datetime=data.get('uploaded_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')),
+        )

documente_shared/domain/entities/processing_case_item_filters.py

@@ -0,0 +1,51 @@
+from dataclasses import dataclass
+from datetime import datetime
+from typing import List, Optional
+
+from documente_shared.application.query_params import QueryParams
+from documente_shared.domain.enums.common import ProcessingStatus
+from documente_shared.domain.enums.document import (
+    DocumentProcessingStatus,
+)
+from documente_shared.domain.enums.processing_case import ProcessingDocumentType
+
+
+@dataclass
+class ProcessingCaseItemFilters(object):
+    sort_order: Optional[str]
+    search: Optional[str]
+    init_date: Optional[datetime]
+    end_date: Optional[datetime]
+    case_id: Optional[str] = None
+    statuses: List[ProcessingStatus] = None
+    document_types: List[ProcessingDocumentType] = None
+    include_archived: bool = False
+
+    def __post_init__(self):
+        self.statuses = self.statuses or []
+        self.document_types = self.document_types or []
+
+    @classmethod
+    def from_params(cls, params: QueryParams) -> "ProcessingCaseItemFilters":
+        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,
+            init_date=params.get_datetime(key="init_date", default=None),
+            end_date=params.get_datetime(key="end_date", default=None),
+            case_id=params.get_str(key="case_id", default=None),
+            statuses=params.get_enum_list(
+                key="statuses",
+                enum_class=DocumentProcessingStatus,
+                default=None,
+            ),
+            document_types=params.get_enum_list(
+                key="document_types",
+                enum_class=ProcessingDocumentType,
+                default=None,
+            ),
+            include_archived=params.get_bool(
+                key="include_archived",
+                default=False,
+            ),
+        )

documente_shared/domain/entities/processing_event.py

@@ -1,49 +1,49 @@
-from dataclasses import dataclass
-from datetime import datetime
-from typing import Optional
-
-from documente_shared.application.time_utils import get_datetime_from_data
-from documente_shared.domain.entities.document import DocumentProcessing
-from documente_shared.domain.entities.processing_case import ProcessingCase
-from documente_shared.domain.enums.common import ProcessingType
-
-
-@dataclass
-class ProcessingEvent(object):
-    processing_type: ProcessingType
-    instance: DocumentProcessing | ProcessingCase | None
-    timestamp: Optional[datetime] = None
-
-    def __eq__(self, other: 'ProcessingEvent') -> bool:
-        if not other:
-            return False
-
-        return (
-            self.processing_type == other.processing_type
-            and self.instance == other.instance
-        )
-
-    @property
-    def to_dict(self) -> dict:
-        return {
-            'processing_type': str(self.processing_type),
-            'instance': self.instance.to_dict,
-            'timestamp': self.timestamp.isoformat() if self.timestamp else None,
-        }
-
-    @classmethod
-    def from_dict(cls, data: dict) -> 'ProcessingEvent':
-        processing_type = ProcessingType.from_value(data.get('processing_type'))
-
-        if processing_type.is_document:
-            processing_instance = DocumentProcessing.from_dict(data.get('instance'))
-        elif processing_type.is_processing_case:
-            processing_instance = ProcessingCase.from_dict(data.get('instance'))
-        else:
-            processing_instance = None
-
-        return cls(
-            processing_type=processing_type,
-            instance=processing_instance,
-            timestamp=get_datetime_from_data(input_datetime=data.get('timestamp')),
-        )
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional
+
+from documente_shared.application.time_utils import get_datetime_from_data
+from documente_shared.domain.entities.document import DocumentProcessing
+from documente_shared.domain.entities.processing_case import ProcessingCase
+from documente_shared.domain.enums.common import ProcessingType
+
+
+@dataclass
+class ProcessingEvent(object):
+    processing_type: ProcessingType
+    instance: DocumentProcessing | ProcessingCase | None
+    timestamp: Optional[datetime] = None
+
+    def __eq__(self, other: 'ProcessingEvent') -> bool:
+        if not other:
+            return False
+
+        return (
+            self.processing_type == other.processing_type
+            and self.instance == other.instance
+        )
+
+    @property
+    def to_dict(self) -> dict:
+        return {
+            'processing_type': str(self.processing_type),
+            'instance': self.instance.to_dict,
+            'timestamp': self.timestamp.isoformat() if self.timestamp else None,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'ProcessingEvent':
+        processing_type = ProcessingType.from_value(data.get('processing_type'))
+
+        if processing_type.is_document:
+            processing_instance = DocumentProcessing.from_dict(data.get('instance'))
+        elif processing_type.is_processing_case:
+            processing_instance = ProcessingCase.from_dict(data.get('instance'))
+        else:
+            processing_instance = None
+
+        return cls(
+            processing_type=processing_type,
+            instance=processing_instance,
+            timestamp=get_datetime_from_data(input_datetime=data.get('timestamp')),
+        )