documente_shared 0.1.145__py3-none-any.whl

documente_shared/domain/entities/processing_event.py

@@ -0,0 +1,71 @@
+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 is_processing_case(self) -> bool:
+        return self.processing_type == ProcessingType.PROCESSING_CASE
+
+    @property
+    def is_document(self) -> bool:
+        return self.processing_type == ProcessingType.DOCUMENT
+
+    @property
+    def uuid(self) -> Optional[str]:
+        if self.is_document:
+            return self.instance.digest
+        elif self.is_processing_case:
+            return self.instance.uuid
+        return None
+
+    @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,
+        }
+
+    @property
+    def to_queue_dict(self) -> dict:
+        dict_data = self.to_dict
+        dict_data['instance'] = self.instance.to_queue_dict
+        return dict_data
+
+    @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/entities/scaling.py

@@ -0,0 +1,31 @@
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class ScalingRequirements(object):
+    lg_documents: Optional[int] = 0
+    md_documents: Optional[int] = 0
+    documents: Optional[int] = 0
+    processing_cases: Optional[int] = 0
+    processing_case_items: Optional[int] = 0
+
+    @property
+    def to_dict(self):
+        return {
+            "lg_documents": self.lg_documents,
+            "md_documents": self.md_documents,
+            "documents": self.documents,
+            "processing_cases": self.processing_cases,
+            "processing_case_items": self.processing_case_items,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "ScalingRequirements":
+        return cls(
+            lg_documents=data.get("lg_documents", 0),
+            md_documents=data.get("md_documents", 0),
+            documents=data.get("documents", 0),
+            processing_cases=data.get("processing_cases", 0),
+            processing_case_items=data.get("processing_case_items", 0),
+        )

documente_shared/domain/enums/circular_oficio.py

@@ -0,0 +1,29 @@
+from documente_shared.domain.base_enum import BaseEnum
+
+
+class CircularOficioType(BaseEnum):
+    RETENCION = "RETENCION"
+    SUSPENSION = "SUSPENSION"
+    REMISION = "REMISION"
+    INFORMATIVA = "INFORMATIVA"
+    NORMATIVA = "NORMATIVA"
+
+    @property
+    def is_normativa(self) -> bool:
+        return self == CircularOficioType.NORMATIVA
+
+    @property
+    def is_retencion(self):
+        return self == CircularOficioType.RETENCION
+
+    @property
+    def is_remision(self):
+        return self == CircularOficioType.REMISION
+
+    @property
+    def is_informativa(self):
+        return self == CircularOficioType.INFORMATIVA
+
+    @property
+    def is_suspension(self) -> bool:
+        return self == CircularOficioType.SUSPENSION

documente_shared/domain/enums/common.py

@@ -0,0 +1,133 @@
+from typing import List
+
+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 procesable_statuses(self) -> List['ProcessingStatus']:
+        return [
+            ProcessingStatus.PENDING,
+            ProcessingStatus.ENQUEUED,
+            ProcessingStatus.PROCESSING,
+        ]
+
+    @property
+    def final_statuses(self) -> List['ProcessingStatus']:
+        return [
+            ProcessingStatus.COMPLETED,
+            ProcessingStatus.FAILED,
+        ]
+
+    @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
+
+
+class TaskResultStatus(BaseEnum):
+    PENDING = "PENDING"
+    SUCCESS = "SUCCESS"
+    IN_PROGRESS = "IN_PROGRESS"
+    FAILURE = "FAILURE"
+
+
+class DocumentViewFormat(BaseEnum):
+    PUBLIC_URL = 'PUBLIC_URL'
+    STORAGE_KEY = 'STORAGE_KEY'
+
+    @property
+    def is_public_url(self):
+        return self == DocumentViewFormat.PUBLIC_URL
+
+    @property
+    def is_object_storage(self):
+        return self == DocumentViewFormat.STORAGE_KEY
+

documente_shared/domain/enums/document.py

@@ -0,0 +1,124 @@
+from typing import List
+
+from documente_shared.domain.base_enum import BaseEnum
+
+
+class DocumentProcessingStatus(BaseEnum):
+    PENDING = 'PENDING'
+    ENQUEUED = 'ENQUEUED'
+    PROCESSING = 'PROCESSING'
+    COMPLETED = 'COMPLETED'
+    INCOMPLETE = 'INCOMPLETE'
+    FAILED = 'FAILED'
+    DELETED = 'DELETED'
+    CANCELLED = 'CANCELLED'
+    IN_REVIEW = 'IN_REVIEW'
+
+    @property
+    def procesable_statuses(self) -> List['DocumentProcessingStatus']:
+        return [
+            DocumentProcessingStatus.PENDING,
+            DocumentProcessingStatus.ENQUEUED,
+            DocumentProcessingStatus.PROCESSING,
+        ]
+
+    @property
+    def final_statuses(self) -> List['DocumentProcessingStatus']:
+        return [
+            DocumentProcessingStatus.COMPLETED,
+            DocumentProcessingStatus.FAILED,
+        ]
+
+    @property
+    def is_pending(self):
+        return self == DocumentProcessingStatus.PENDING
+
+    @property
+    def is_enqueued(self):
+        return self == DocumentProcessingStatus.ENQUEUED
+
+    @property
+    def is_processing(self):
+        return self == DocumentProcessingStatus.PROCESSING
+
+    @property
+    def is_completed(self):
+        return self == DocumentProcessingStatus.COMPLETED
+
+    @property
+    def is_incomplete(self):
+        return self == DocumentProcessingStatus.INCOMPLETE
+
+    @property
+    def is_failed(self):
+        return self == DocumentProcessingStatus.FAILED
+
+    @property
+    def is_deleted(self):
+        return self == DocumentProcessingStatus.DELETED
+
+    @property
+    def is_cancelled(self):
+        return self == DocumentProcessingStatus.CANCELLED
+
+    @property
+    def is_in_review(self):
+        return self == DocumentProcessingStatus.IN_REVIEW
+
+
+class DocumentProcessingCategory(BaseEnum):
+    CIRCULAR = 'CIRCULAR'
+    DESGRAVAMEN = 'DESGRAVAMEN'
+
+    @property
+    def is_circular(self):
+        return self == DocumentProcessingCategory.CIRCULAR
+
+    @property
+    def is_desgravamen(self):
+        return self == DocumentProcessingCategory.DESGRAVAMEN
+
+
+class DocumentProcessingSource(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 == DocumentProcessingSource.AGENT_UI
+
+    @property
+    def is_agent_crawler(self):
+        return self == DocumentProcessingSource.AGENT_CRAWLER
+
+    @property
+    def is_platform_ui(self):
+        return self == DocumentProcessingSource.PLATFORM_UI
+
+    @property
+    def is_platform_api(self):
+        return self == DocumentProcessingSource.PLATFORM_API
+
+    @property
+    def is_aws_console(self):
+        return self == DocumentProcessingSource.AWS_CONSOLE
+
+    @property
+    def is_local_manual(self):
+        return self == DocumentProcessingSource.LOCAL_MANUAL
+
+
+class DocumentProcessingSubCategory(BaseEnum):
+    # Circulares
+    CC_COMBINADA = 'CC_COMBINADA'
+    CC_NORMATIVA = 'CC_NORMATIVA'
+    CC_INFORMATIVA = 'CC_INFORMATIVA'
+    CC_RETENCION_SUSPENSION_REMISION = 'CC_RETENCION_SUSPENSION_REMISION'
+
+    # Desgravamenes
+    DS_CREDISEGURO = 'DS_CREDISEGURO'
+

documente_shared/domain/enums/document_type_record.py

@@ -0,0 +1,13 @@
+from src.common.domain.base_enum import BaseEnum
+
+class DocumentTypeRecord(BaseEnum):
+    DOCUMENT_PROCESSING = 'DOCUMENT_PROCESSING'
+    PROCESSING_CASE_ITEM = 'PROCESSING_CASE_ITEM'
+    
+    @property
+    def is_document_processing(self):
+        return self == DocumentTypeRecord.DOCUMENT_PROCESSING
+    
+    @property
+    def is_processing_case_item(self):
+        return self == DocumentTypeRecord.PROCESSING_CASE_ITEM

documente_shared/domain/enums/processing_case.py

@@ -0,0 +1,66 @@
+from documente_shared.domain.base_enum import BaseEnum
+
+
+class ProcessingCaseType(BaseEnum):
+    BCP_MICROCREDITO = 'BCP_MICROCREDITO'
+    UNIVIDA_SOAT = 'UNIVIDA_SOAT'
+    AGNOSTIC = 'AGNOSTIC'
+
+    @property
+    def is_bcp_microcredito(self):
+        return self == ProcessingCaseType.BCP_MICROCREDITO
+
+    @property
+    def is_univida_soat(self):
+        return self == ProcessingCaseType.UNIVIDA_SOAT
+
+    @property
+    def is_agnostic(self):
+        return self == ProcessingCaseType.AGNOSTIC
+
+
+
+
+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/domain/exceptions.py

@@ -0,0 +1,5 @@
+
+
+
+class InMemoryDocumentContentError(Exception):
+    pass

documente_shared/domain/interfaces/scaling.py

@@ -0,0 +1,10 @@
+from abc import ABC, abstractmethod
+
+from documente_shared.domain.entities.scaling import ScalingRequirements
+
+
+class ScalingService(ABC):
+
+    @abstractmethod
+    def get_requirements(self) -> ScalingRequirements:
+        raise NotImplementedError

documente_shared/domain/repositories/document.py

@@ -0,0 +1,24 @@
+from abc import ABC, abstractmethod
+from typing import Optional, List
+
+from documente_shared.domain.entities.document import DocumentProcessing
+from documente_shared.domain.enums.document import DocumentProcessingStatus
+
+
+class DocumentProcessingRepository(ABC):
+
+    @abstractmethod
+    def find(self, digest: str, read_bytes: bool = False) -> Optional[DocumentProcessing]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def persist(self, instance: DocumentProcessing, read_bytes: bool = False) -> DocumentProcessing:
+        raise NotImplementedError
+
+    @abstractmethod
+    def remove(self, instance: DocumentProcessing):
+        raise NotImplementedError
+
+    @abstractmethod
+    def filter(self, statuses: List[DocumentProcessingStatus]) -> List[DocumentProcessing]:
+        raise NotImplementedError

documente_shared/domain/repositories/processing_case.py

@@ -0,0 +1,36 @@
+from abc import ABC, abstractmethod
+from typing import Optional, List
+
+from documente_shared.domain.entities.processing_case import ProcessingCase
+from documente_shared.domain.entities.processing_case_filters import ProcessingCaseFilters
+from documente_shared.domain.enums.common import DocumentViewFormat
+
+
+class ProcessingCaseRepository(ABC):
+
+    @abstractmethod
+    def find(
+        self,
+        uuid: str,
+        include_items: bool = False,
+        include_items_bytes: bool = False,
+        view_format: DocumentViewFormat = DocumentViewFormat.PUBLIC_URL,
+    ) -> Optional[ProcessingCase]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def persist(
+        self,
+        instance: ProcessingCase,
+        persist_items: bool = False,
+        view_format: DocumentViewFormat = DocumentViewFormat.PUBLIC_URL,
+    ) -> ProcessingCase:
+        raise NotImplementedError
+
+    @abstractmethod
+    def remove(self, instance: ProcessingCase):
+        raise NotImplementedError
+
+    @abstractmethod
+    def filter(self, filters: ProcessingCaseFilters) -> List[ProcessingCase]:
+        raise NotImplementedError

documente_shared/domain/repositories/processing_case_item.py

@@ -0,0 +1,49 @@
+from abc import ABC, abstractmethod
+from typing import Optional, List
+
+from documente_shared.domain.entities.processing_case_item import ProcessingCaseItem
+from documente_shared.domain.entities.processing_case_item_filters import ProcessingCaseItemFilters
+from documente_shared.domain.enums.common import DocumentViewFormat
+
+
+class ProcessingCaseItemRepository(ABC):
+
+    @abstractmethod
+    def find(
+        self,
+        uuid: str,
+        read_bytes: bool = False,
+        view_format: DocumentViewFormat = DocumentViewFormat.PUBLIC_URL,
+    ) -> Optional[ProcessingCaseItem]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def find_by_digest(
+        self,
+        digest: str,
+        read_bytes: bool = False,
+        view_format: DocumentViewFormat = DocumentViewFormat.PUBLIC_URL,
+    ) -> Optional[ProcessingCaseItem]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def persist(
+        self,
+        instance: ProcessingCaseItem,
+        read_bytes: bool = False,
+        persist_bytes: bool = False,
+        view_format: DocumentViewFormat = DocumentViewFormat.PUBLIC_URL,
+    ) -> ProcessingCaseItem:
+        raise NotImplementedError
+
+    @abstractmethod
+    def remove(self, instance: ProcessingCaseItem):
+        raise NotImplementedError
+
+    @abstractmethod
+    def filter(
+        self,
+        filters: ProcessingCaseItemFilters,
+        view_format: DocumentViewFormat = DocumentViewFormat.PUBLIC_URL,
+    ) -> List[ProcessingCaseItem]:
+        raise NotImplementedError

documente_shared/infrastructure/documente_client.py

@@ -0,0 +1,27 @@
+from requests import Session
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class DocumenteClientMixin(object):
+    api_url: str
+    api_key: str
+    tenant: Optional[str] = None
+    session: Optional[Session] = None
+
+    def __post_init__(self):
+        if self.session is None:
+            self.session = Session()
+        self.session.headers.update(self.get_common_headers())
+
+
+    def get_common_headers(self) -> dict:
+        common_headers = {
+            "X-Api-Key": self.api_key,
+            "Content-Type": "application/json"
+        }
+        if self.tenant:
+            common_headers.update({"X-Tenant": self.tenant})
+        return common_headers
+