documente_shared 0.1.67__py3-none-any.whl → 0.1.70__py3-none-any.whl

documente_shared/domain/entities/in_memory_result.py

@@ -0,0 +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'),
+        )

documente_shared/domain/entities/processing_case.py

@@ -0,0 +1,139 @@
+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):
+    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.id == other.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 {
+            'id': self.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(
+            id=data.get('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', [])
+            ],
+        )

documente_shared/domain/entities/processing_case_item.py

@@ -0,0 +1,211 @@
+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):
+    id: 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
+    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.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.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 {
+            'id': self.id,
+            'case_id': self.case_id,
+            'digest': self.digest,
+            'status': str(self.status),
+            'document': self.document.to_dict,
+            'document_type': 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
+            ),
+            '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()
+        simple_dict.pop('metadata_items')
+        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',
+            '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(
+            id=data.get('id'),
+            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
+            ),
+            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_event.py

@@ -0,0 +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')),
+        )

documente_shared/domain/enums/common.py

@@ -0,0 +1,95 @@
+from documente_shared.domain.base_enum import BaseEnum
+
+
+class ProcessingSource(BaseEnum):
+    AGENT_UI = 'AGENT_UI'
+    AGENT_CRAWLER = 'AGENT_CRAWLER'
+    PLATFORM_UI = 'PLATFORM_UI'
+    PLATFORM_API = 'PLATFORM_API'
+    AWS_CONSOLE = 'AWS_CONSOLE'
+    LOCAL_MANUAL = 'LOCAL_MANUAL'
+
+    @property
+    def is_agent_ui(self):
+        return self == ProcessingSource.AGENT_UI
+
+    @property
+    def is_agent_crawler(self):
+        return self == ProcessingSource.AGENT_CRAWLER
+
+    @property
+    def is_platform_ui(self):
+        return self == ProcessingSource.PLATFORM_UI
+
+    @property
+    def is_platform_api(self):
+        return self == ProcessingSource.PLATFORM_API
+
+    @property
+    def is_aws_console(self):
+        return self == ProcessingSource.AWS_CONSOLE
+
+    @property
+    def is_local_manual(self):
+        return self == ProcessingSource.LOCAL_MANUAL
+
+
+class ProcessingStatus(BaseEnum):
+    PENDING = 'PENDING'
+    ENQUEUED = 'ENQUEUED'
+    PROCESSING = 'PROCESSING'
+    COMPLETED = 'COMPLETED'
+    INCOMPLETE = 'INCOMPLETE'
+    FAILED = 'FAILED'
+    DELETED = 'DELETED'
+    CANCELLED = 'CANCELLED'
+    IN_REVIEW = 'IN_REVIEW'
+
+    @property
+    def is_pending(self):
+        return self == ProcessingStatus.PENDING
+
+    @property
+    def is_enqueued(self):
+        return self == ProcessingStatus.ENQUEUED
+
+    @property
+    def is_processing(self):
+        return self == ProcessingStatus.PROCESSING
+
+    @property
+    def is_completed(self):
+        return self == ProcessingStatus.COMPLETED
+
+    @property
+    def is_incomplete(self):
+        return self == ProcessingStatus.INCOMPLETE
+
+    @property
+    def is_failed(self):
+        return self == ProcessingStatus.FAILED
+
+    @property
+    def is_deleted(self):
+        return self == ProcessingStatus.DELETED
+
+    @property
+    def is_cancelled(self):
+        return self == ProcessingStatus.CANCELLED
+
+    @property
+    def is_in_review(self):
+        return self == ProcessingStatus.IN_REVIEW
+
+
+class ProcessingType(BaseEnum):
+    DOCUMENT = 'DOCUMENT'
+    PROCESSING_CASE = 'PROCESSING_CASE'
+
+    @property
+    def is_document(self):
+        return self == ProcessingType.DOCUMENT
+
+    @property
+    def is_processing_case(self):
+        return self == ProcessingType.PROCESSING_CASE

documente_shared/domain/enums/processing_case.py

@@ -0,0 +1,54 @@
+from documente_shared.domain.base_enum import BaseEnum
+
+
+class ProcessingCaseCategory(BaseEnum):
+    BCP_MICROCREDITO = 'BCP_MICROCREDITO'
+
+    @property
+    def is_bcp_microcredito(self):
+        return self == ProcessingCaseCategory.BCP_MICROCREDITO
+
+
+class ProcessingDocumentType(BaseEnum):
+    REVIEW_CHECKLIST = 'REVISION_CHECKLIST'
+    SOLICITUD_DE_CREDITO = 'SOLICITUD_DE_CREDITO'
+    RESOLUCION_DE_CREDITO = 'RESOLUCION_DE_CREDITO'
+    CEDULA_DE_IDENTIDAD = 'CEDULA_DE_IDENTIDAD'
+    NIT = 'NIT'
+    FICHA_VERIFICACION = 'FICHA_VERIFICACION'
+    FACTURA_ELECTRICIDAD = 'FACTURA_ELECTRICIDAD'
+    CARTA_CLIENTE = 'CARTA_CLIENTE'
+
+    @property
+    def is_review_checklist(self):
+        return self == ProcessingDocumentType.REVIEW_CHECKLIST
+
+    @property
+    def is_solicitud_de_credito(self):
+        return self == ProcessingDocumentType.SOLICITUD_DE_CREDITO
+
+    @property
+    def is_resolucion_de_credito(self):
+        return self == ProcessingDocumentType.RESOLUCION_DE_CREDITO
+
+    @property
+    def is_cedula_de_identidad(self):
+        return self == ProcessingDocumentType.CEDULA_DE_IDENTIDAD
+
+    @property
+    def is_nit(self):
+        return self == ProcessingDocumentType.NIT
+
+    @property
+    def is_ficha_verificacion(self):
+        return self == ProcessingDocumentType.FICHA_VERIFICACION
+
+    @property
+    def is_factura_electricidad(self):
+        return self == ProcessingDocumentType.FACTURA_ELECTRICIDAD
+
+    @property
+    def is_carta_cliente(self):
+        return self == ProcessingDocumentType.CARTA_CLIENTE
+
+

{documente_shared-0.1.67.dist-info → documente_shared-0.1.70.dist-info}/METADATA

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

{documente_shared-0.1.67.dist-info → documente_shared-0.1.70.dist-info}/RECORD

@@ -11,13 +11,20 @@ documente_shared/domain/constants.py,sha256=jOlMKFq12FgiYMJcQHku8IVwuOE5t-HEPuSV
 documente_shared/domain/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 documente_shared/domain/entities/document.py,sha256=kaLuVJ-LVQMUdQhCReQ2Mkl7-Kmws6-TNxKnlXogYSk,12603
 documente_shared/domain/entities/document_metadata.py,sha256=ygyFIC5qwxlm8DUM5kvVFny9zJfPQS8vNLM2br5XsQ8,2353
-documente_shared/domain/enums.py,sha256=NltZA1YVgJ7dVfSQdJFIE0ZUGf9Y-nxNXsVQ6GiPLL4,1827
+documente_shared/domain/entities/in_memory_result.py,sha256=Q1E9vnLL5Hz5xunOqWtQmJOMjoK5KN42LZr18GlBAZo,1246
+documente_shared/domain/entities/processing_case.py,sha256=PuwWQuXIIP5wlkWBCrkF-61TfgKSYwc9HZl1JR13xhk,4955
+documente_shared/domain/entities/processing_case_item.py,sha256=5wuZylIc_Lanh5PnY4ghEgbQhCtBDCExh4KRW6ZGK_4,7684
+documente_shared/domain/entities/processing_event.py,sha256=m1O0gcNaE_SszeIhxM3uYPHSpyOUmize6mfRw1_bYZo,1723
+documente_shared/domain/enums/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+documente_shared/domain/enums/common.py,sha256=vXldMUPhhWo0PfTgYwDSjI8bur_lYcImZYiV7yAO7DQ,2262
+documente_shared/domain/enums/document.py,sha256=NltZA1YVgJ7dVfSQdJFIE0ZUGf9Y-nxNXsVQ6GiPLL4,1827
+documente_shared/domain/enums/processing_case.py,sha256=DLVk0VnVzrKs1CvXVGHV9p8mBUHLUrOSJJ1POE-Ek3o,1546
 documente_shared/domain/repositories.py,sha256=g3qLUy2kT8esmvU4VxxSVnDaXeySKKQ7mUvIvxOwh9A,757
 documente_shared/infrastructure/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 documente_shared/infrastructure/dynamo_repositories.py,sha256=SEad_HLppp2h_BKDSzb9oo1VlAVRZWelOPvJPlDwbzQ,1453
 documente_shared/infrastructure/dynamo_table.py,sha256=dK05KgFvIYCmOdMpq9-OV_OBrP6cCngiUikCJrxlwt4,2112
 documente_shared/infrastructure/s3_bucket.py,sha256=vT_yN42RFQXubtUn8ln-j13Os_-25UGClVtXg5Bkv6I,1932
 documente_shared/infrastructure/sqs_queue.py,sha256=PSiTAnjXvQ-W-9mzLpH2UjbQJTvYkMiaxNaMecF-cR4,1505
-documente_shared-0.1.67.dist-info/METADATA,sha256=LdE6JvvmvgjXiBiG3vKHKNaxC6__DzwSaVnTU5GqSZQ,800
-documente_shared-0.1.67.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-documente_shared-0.1.67.dist-info/RECORD,,
+documente_shared-0.1.70.dist-info/METADATA,sha256=JCm5S835mggDqZMKE320WqYbKgyH79nvdZMXIIaMnEU,800
+documente_shared-0.1.70.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+documente_shared-0.1.70.dist-info/RECORD,,