documente_shared 0.1.145__py3-none-any.whl

documente_shared/infrastructure/dynamo_table.py

@@ -0,0 +1,75 @@
+import boto3
+
+from dataclasses import dataclass
+from boto3.dynamodb.conditions import Key
+
+
+RETURN_VALUES = 'UPDATED_NEW'
+
+
+@dataclass
+class DynamoDBTable(object):
+    table_name: str
+
+    def __post_init__(self):
+        self._table = boto3.resource('dynamodb').Table(self.table_name)
+
+    def get(self, key: dict):
+        return self._table.get_item(Key=key).get('Item')
+
+    def get_all(self):
+        return self._table.scan().get('Items')
+
+    def upsert(self, key, attributes):
+        return self.put({**key, **attributes})
+
+
+    def filter_by(self, attribute: str, target_value: str):
+        return self._table.query(
+            FilterExpression=Key(attribute).eq(target_value),
+        ).get('Items')
+
+    def put(self, attributes: dict, condition: dict = None):
+        extra_args = {}
+        if condition:
+            extra_args['ConditionExpression'] = condition
+        return self._table.put_item(Item=attributes, **extra_args)
+
+
+    def update(self, key: str, attributes: dict):
+        return self._table.update_item(
+            Key=key,
+            UpdateExpression=self._update_expression(attributes),
+            ExpressionAttributeNames=self._expression_attribute_names(attributes),
+            ExpressionAttributeValues=self._expression_attribute_values(attributes),
+            ReturnValues=RETURN_VALUES,
+        )
+
+    def delete(self, key: dict):
+        return self._table.delete_item(Key=key)
+
+    def count(self) -> int:
+        return self._table.item_count
+
+    @classmethod
+    def _update_expression(cls, attributes):
+        return 'SET {param}'.format(
+            param=','.join(
+                '#{key}=:{key}'.format(
+                    key=key,
+                )
+                for key in attributes
+            ),
+        )
+
+    @classmethod
+    def _expression_attribute_names(cls, attributes):
+        return {
+            '#{key}'.format(key=key): key for key in attributes
+        }
+
+    @classmethod
+    def _expression_attribute_values(cls, attributes):
+        return {
+            ':{key}'.format(key=key): attr for key, attr in attributes.items()
+        }

documente_shared/infrastructure/lambdas.py

@@ -0,0 +1,14 @@
+import json
+import boto3
+
+
+def invoke_lambda(function_name: str, payload: dict) -> dict | list | None:
+    client = boto3.client('lambda')
+
+    response = client.invoke(
+        FunctionName=function_name,
+        InvocationType='RequestResponse',
+        Payload=json.dumps(payload),
+    )
+
+    return json.loads(response['Payload'].read().decode('utf-8'))

documente_shared/infrastructure/repositories/dynamo_document.py

@@ -0,0 +1,43 @@
+from typing import Optional, List
+
+from boto3.dynamodb.conditions import Key
+
+from documente_shared.domain.entities.document import DocumentProcessing
+from documente_shared.domain.enums.document import DocumentProcessingStatus
+from documente_shared.domain.repositories.document import DocumentProcessingRepository
+
+from documente_shared.infrastructure.dynamo_table import DynamoDBTable
+
+
+class DynamoDocumentProcessingRepository(
+    DynamoDBTable,
+    DocumentProcessingRepository,
+):
+    def find(self, digest: str, read_bytes: bool = False) -> Optional[DocumentProcessing]:
+        item = self.get(key={'digest': digest})
+        if item:
+            return DocumentProcessing.from_dict(item)
+        return None
+
+    def persist(self, instance: DocumentProcessing, read_bytes: bool = False) -> DocumentProcessing:
+        self.put(instance.to_simple_dict)
+        return instance
+
+    def remove(self, instance: DocumentProcessing):
+        self.delete(key={'digest': instance.digest})
+
+    def filter(self, statuses: List[DocumentProcessingStatus]) -> List[DocumentProcessing]:
+        items = []
+
+        for status in statuses:
+            response = self._table.query(
+                IndexName='status',
+                KeyConditionExpression=Key('status').eq(status.value),
+            )
+            status_items = response.get('Items', [])
+            items.extend(status_items)
+
+        return [
+            DocumentProcessing.from_dict(item)
+            for item in items
+        ]

documente_shared/infrastructure/repositories/dynamo_processing_case.py

@@ -0,0 +1,55 @@
+from typing import Optional, List
+
+from boto3.dynamodb.conditions import Key
+
+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
+from documente_shared.domain.repositories.processing_case import ProcessingCaseRepository
+
+from documente_shared.infrastructure.dynamo_table import DynamoDBTable
+
+
+class DynamoProcessingCaseRepository(
+    DynamoDBTable,
+    ProcessingCaseRepository,
+):
+    def find(
+        self,
+        uuid: str,
+        include_items: bool = False,
+        include_items_bytes: bool = False,
+        view_format: DocumentViewFormat = DocumentViewFormat.PUBLIC_URL,
+    ) -> Optional[ProcessingCase]:
+        item = self.get(key={'uuid': uuid})
+        if item:
+            return ProcessingCase.from_dict(item)
+        return None
+
+    def persist(
+        self,
+        instance: ProcessingCase,
+        persist_items: bool = False,
+        view_format: DocumentViewFormat = DocumentViewFormat.PUBLIC_URL,
+    ) -> ProcessingCase:
+        self.put(instance.to_persist_dict)
+        return instance
+
+    def remove(self, instance: ProcessingCase):
+        self.delete(key={'uuid': instance.uuid})
+
+    def filter(self, filters: ProcessingCaseFilters) -> List[ProcessingCase]:
+        items = []
+
+        for status in filters.statuses:
+            response = self._table.query(
+                IndexName='status',
+                KeyConditionExpression=Key('status').eq(status.value),
+            )
+            status_items = response.get('Items', [])
+            items.extend(status_items)
+
+        return [
+            ProcessingCase.from_dict(item)
+            for item in items
+        ]

documente_shared/infrastructure/repositories/dynamo_processing_case_item.py

@@ -0,0 +1,70 @@
+from typing import Optional, List
+
+from boto3.dynamodb.conditions import Key
+
+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
+from documente_shared.domain.repositories.processing_case_item import ProcessingCaseItemRepository
+
+from documente_shared.infrastructure.dynamo_table import DynamoDBTable
+
+
+class DynamoProcessingCaseItemRepository(
+    DynamoDBTable,
+    ProcessingCaseItemRepository,
+):
+    def find(
+        self,
+        uuid: str,
+        read_bytes: bool = False,
+        view_format: DocumentViewFormat = DocumentViewFormat.PUBLIC_URL,
+    ) -> Optional[ProcessingCaseItem]:
+        item = self.get(key={'digest': uuid})
+        if item:
+            return ProcessingCaseItem.from_dict(item)
+        return None
+
+    def find_by_digest(
+        self,
+        digest: str,
+        read_bytes: bool = False,
+        view_format: DocumentViewFormat = DocumentViewFormat.PUBLIC_URL,
+    ) -> Optional[ProcessingCaseItem]:
+        item = self.get(key={'digest': digest})
+        if item:
+            return ProcessingCaseItem.from_dict(item)
+        return None
+
+    def persist(
+        self,
+        instance: ProcessingCaseItem,
+        read_bytes: bool = False,
+        persist_bytes: bool = False,
+        view_format: DocumentViewFormat = DocumentViewFormat.PUBLIC_URL,
+    ) -> ProcessingCaseItem:
+        self.put(instance.to_simple_dict)
+        return instance
+
+    def remove(self, instance: ProcessingCaseItem):
+        self.delete(key={'case_id': instance.case_id})
+
+    def filter(
+        self,
+        filters: ProcessingCaseItemFilters,
+        view_format: DocumentViewFormat = DocumentViewFormat.PUBLIC_URL,
+    ) -> List[ProcessingCaseItem]:
+        items = []
+
+        for status in filters.statuses:
+            response = self._table.query(
+                IndexName='status',
+                KeyConditionExpression=Key('status').eq(status.value),
+            )
+            status_items = response.get('Items', [])
+            items.extend(status_items)
+
+        return [
+            ProcessingCaseItem.from_dict(item)
+            for item in items
+        ]

documente_shared/infrastructure/repositories/http_document.py

@@ -0,0 +1,66 @@
+from dataclasses import dataclass
+from typing import List, Optional
+
+from loguru import logger
+from requests import Response
+
+from documente_shared.application.payloads import camel_to_snake
+from documente_shared.application.query_params import parse_bool_to_str
+from documente_shared.domain.entities.document import DocumentProcessing
+from documente_shared.domain.enums.document import DocumentProcessingStatus
+from documente_shared.domain.repositories.document import DocumentProcessingRepository
+from documente_shared.infrastructure.documente_client import DocumenteClientMixin
+
+
+@dataclass
+class HttpDocumentProcessingRepository(
+    DocumenteClientMixin,
+    DocumentProcessingRepository,
+):
+    def find(self, digest: str, read_bytes: bool = False) -> Optional[DocumentProcessing]:
+        params = {
+            "read_bytes": parse_bool_to_str(read_bytes),
+        }
+        response = self.session.get(
+            url=f"{self.api_url}/v1/documents/{digest}/",
+            params=params,
+        )
+        if response.status_code not in [200, 201]:
+            return None
+        return self._build_document_processing(response)
+
+    def persist(self, instance: DocumentProcessing, read_bytes: bool = False) -> DocumentProcessing:
+        logger.info(f"PERSISTING_DOCUMENT: data={instance.to_simple_dict}")
+        params = {
+            "read_bytes": parse_bool_to_str(read_bytes),
+        }
+        response = self.session.put(
+            url=f"{self.api_url}/v1/documents/{instance.digest}/",
+            params=params,
+            json=instance.to_simple_dict,
+        )
+        if response.status_code not in [200, 201]:
+            raise Exception(f'Error persisting document processing: {response.text}')
+        return self._build_document_processing(response)
+    
+    def remove(self, instance: DocumentProcessing):
+        self.session.delete(f"{self.api_url}/v1/documents/{instance.digest}/")
+        
+    def filter(self, statuses: List[DocumentProcessingStatus]) -> List[DocumentProcessing]:
+        response = self.session.get(f"{self.api_url}/v1/documents/?statuses={statuses}")
+        if response.status_code not in [200, 201]:
+            return []
+        raw_response = response.json()
+        return [
+            DocumentProcessing.from_dict(camel_to_snake(item['documentProcessing']))
+            for item in raw_response.get('data', [])
+        ]
+
+    
+    @classmethod
+    def _build_document_processing(cls, response: Response) -> DocumentProcessing:
+        response_json = response.json()
+        instance_data = response_json.get('data', {})
+        return DocumentProcessing.from_dict(camel_to_snake(instance_data))
+    
+    

documente_shared/infrastructure/repositories/http_processing_case.py

@@ -0,0 +1,82 @@
+from dataclasses import dataclass
+from typing import List, Optional
+
+from loguru import logger
+from requests import Response
+
+from documente_shared.application.payloads import camel_to_snake
+from documente_shared.application.query_params import parse_bool_to_str
+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
+from documente_shared.domain.repositories.processing_case import ProcessingCaseRepository
+from documente_shared.infrastructure.documente_client import DocumenteClientMixin
+
+
+@dataclass
+class HttpProcessingCaseRepository(
+    DocumenteClientMixin,
+    ProcessingCaseRepository,
+):
+    def find(
+        self,
+        uuid: str,
+        include_items: bool = False,
+        include_items_bytes: bool = False,
+        view_format: DocumentViewFormat = DocumentViewFormat.PUBLIC_URL,
+    ) -> Optional[ProcessingCase]:
+        params = {
+            "view_format": str(view_format),
+        }
+        response = self.session.get(
+            url=f"{self.api_url}/v1/processing-cases/{uuid}/",
+            params=params,
+        )
+        if response.status_code not in [200, 201]:
+            return None
+        return self._build_processing_case(response)
+
+    def persist(
+        self,
+        instance: ProcessingCase,
+        persist_items: bool = False,
+        view_format: DocumentViewFormat = DocumentViewFormat.PUBLIC_URL,
+    ) -> ProcessingCase:
+        logger.info(f"PERSISTING_PROCESSING_CASE: data={instance.to_queue_dict}")
+        params = {
+            "persist_items": parse_bool_to_str(persist_items),
+            "view_format": str(view_format),
+        }
+        response = self.session.put(
+            url=f"{self.api_url}/v1/processing-cases/{instance.uuid}/",
+            params=params,
+            json=instance.to_dict,
+        )
+        if response.status_code not in [200, 201]:
+            raise Exception(f'Error persisting processing case: {response.text}')
+        return self._build_processing_case(response)
+
+    def remove(self, instance: ProcessingCase):
+        self.session.delete(f"{self.api_url}/v1/processing-cases/{instance.uuid}/")
+
+    def filter(self, filters: ProcessingCaseFilters) -> List[ProcessingCase]:
+        response = self.session.get(
+            url=f"{self.api_url}/v1/processing-cases/",
+            headers={
+                "X-Tenant": filters.tenant_slug,
+            }
+        )
+        if response.status_code not in [200, 201]:
+            return []
+        raw_response = response.json()
+        return [
+            ProcessingCase.from_persist_dict(camel_to_snake(item_data))
+            for item_data in raw_response.get('data', [])
+        ]
+
+
+    @classmethod
+    def _build_processing_case(cls, response: Response) -> ProcessingCase:
+        response_json = response.json()
+        instance_data = response_json.get('data', {})
+        return ProcessingCase.from_persist_dict(camel_to_snake(instance_data))

documente_shared/infrastructure/repositories/http_processing_case_item.py

@@ -0,0 +1,118 @@
+from dataclasses import dataclass
+from typing import List, Optional
+
+from loguru import logger
+from requests import Response
+
+from documente_shared.application.payloads import camel_to_snake
+from documente_shared.application.query_params import parse_bool_to_str
+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
+from documente_shared.domain.repositories.processing_case_item import ProcessingCaseItemRepository
+from documente_shared.infrastructure.documente_client import DocumenteClientMixin
+
+
+@dataclass
+class HttpProcessingCaseItemRepository(
+    DocumenteClientMixin,
+    ProcessingCaseItemRepository,
+):
+    def find(
+        self,
+        uuid: str,
+        read_bytes: bool = False,
+        view_format: DocumentViewFormat = DocumentViewFormat.PUBLIC_URL,
+    ) -> Optional[ProcessingCaseItem]:
+        response = self.session.get(
+            url=f"{self.api_url}/v1/processing-case-items/{uuid}/?read_bytes={parse_bool_to_str(read_bytes)}",
+        )
+        if response.status_code not in [200, 201]:
+            return None
+        return self._build_processing_case_item(response)
+
+    def find_by_digest(
+        self,
+        digest: str,
+        read_bytes: bool = False,
+        view_format: DocumentViewFormat = DocumentViewFormat.PUBLIC_URL,
+    ) -> Optional[ProcessingCaseItem]:
+        params = {
+            "read_bytes": parse_bool_to_str(read_bytes),
+            "view_format": str(view_format),
+        }
+        response = self.session.get(
+            url=f"{self.api_url}/v1/processing-case-items/{digest}/",
+            params=params,
+        )
+        if response.status_code not in [200, 201]:
+            return None
+        return self._build_processing_case_item(response)
+
+    def persist(
+        self,
+        instance: ProcessingCaseItem,
+        read_bytes: bool = False,
+        persist_bytes: bool = False,
+        view_format: DocumentViewFormat = DocumentViewFormat.PUBLIC_URL,
+    ) -> ProcessingCaseItem:
+        logger.info(f"PERSISTING_PROCESSING_CASE_ITEM: data={instance.to_queue_dict}")
+        params = {
+            "read_bytes": parse_bool_to_str(read_bytes),
+            "view_format": str(view_format),
+        }
+        response: Response = self.session.put(
+            url=f"{self.api_url}/v1/processing-case-items/{instance.uuid}/",
+            params=params,
+            json=(
+                instance.to_persist_dict
+                if persist_bytes else instance.to_queue_dict
+            ),
+        )
+        if response.status_code not in [200, 201]:
+            logger.info(f"PERSISTING_PROCESSING_CASE_ITEM ERROR: data={response.text}")
+            return instance
+        return self._build_processing_case_item(response)
+
+    def remove(self, instance: ProcessingCaseItem):
+        self.session.delete(f"{self.api_url}/v1/processing-case-items/{instance.uuid}/")
+
+    def filter(
+        self,
+        filters: ProcessingCaseItemFilters,
+        view_format: DocumentViewFormat = DocumentViewFormat.PUBLIC_URL,
+    ) -> List[ProcessingCaseItem]:
+        params = {
+            "view_format": str(view_format),
+        }
+        response = self.session.get(
+            url=f"{self.api_url}/v1/processing-case-items/",
+            params=params,
+        )
+        if response.status_code not in [200, 201]:
+            return []
+        raw_response = response.json()
+        return [
+            ProcessingCaseItem.from_dict(camel_to_snake(item_data))
+            for item_data in raw_response.get('data', [])
+        ]
+
+    def filter_with_tenant(
+        self,
+        tenant_slug: str,
+        filters: ProcessingCaseItemFilters,
+    ) -> List[ProcessingCaseItem]:
+        response = self.session.get(f"{self.api_url}/v1/processing-case-items/")
+        if response.status_code not in [200, 201]:
+            return []
+        raw_response = response.json()
+        return [
+            ProcessingCaseItem.from_dict(camel_to_snake(item_data))
+            for item_data in raw_response.get('data', [])
+        ]
+
+    @classmethod
+    def _build_processing_case_item(cls, response: Response) -> ProcessingCaseItem:
+        response_json = response.json()
+        instance_data = response_json.get('data', {})
+        return ProcessingCaseItem.from_dict(camel_to_snake(instance_data))

documente_shared/infrastructure/repositories/mem_document.py

@@ -0,0 +1,46 @@
+from dataclasses import dataclass
+from typing import List, Optional
+
+from documente_shared.domain.entities.document import DocumentProcessing
+from documente_shared.domain.enums.common import DocumentViewFormat
+from documente_shared.domain.enums.document import DocumentProcessingStatus
+from documente_shared.domain.repositories.document import DocumentProcessingRepository
+
+
+@dataclass
+class MemoryDocumentProcessingRepository(DocumentProcessingRepository):
+    collection: dict[str, DocumentProcessing] = None
+
+    def __post_init__(self):
+        self.collection = self.collection or {}
+
+    def find(
+        self,
+        digest: str,
+        view_format: DocumentViewFormat = DocumentViewFormat.PUBLIC_URL,
+    ) -> Optional[DocumentProcessing]:
+        if digest in self.collection:
+            return self.collection[digest]
+        return None
+
+
+    def persist(
+        self,
+        instance: DocumentProcessing,
+        view_format: DocumentViewFormat = DocumentViewFormat.PUBLIC_URL,
+    ) -> DocumentProcessing:
+        self.collection[instance.digest] = instance
+        return instance
+
+    def remove(self, instance: DocumentProcessing):
+        if instance.digest in self.collection:
+            del self.collection[instance.digest]
+        return None
+
+    def filter(self, statuses: List[DocumentProcessingStatus]) -> List[DocumentProcessing]:
+        items = []
+        for status in statuses:
+            items.extend(
+                [item for item in self.collection.values() if item.status == status]
+            )
+        return items

documente_shared/infrastructure/repositories/mem_processing_case.py

@@ -0,0 +1,44 @@
+from dataclasses import dataclass
+from typing import List, Optional
+
+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
+
+from documente_shared.domain.repositories.processing_case import ProcessingCaseRepository
+
+
+@dataclass
+class MemoryProcessingCaseRepository(ProcessingCaseRepository):
+    collection: dict[str, ProcessingCase] = None
+
+    def __post_init__(self):
+        self.collection = self.collection or {}
+
+    def find(
+        self,
+        uuid: str,
+        include_items: bool = False,
+        include_items_bytes: bool = False,
+        view_format: DocumentViewFormat = DocumentViewFormat.PUBLIC_URL,
+    ) -> Optional[ProcessingCase]:
+        if uuid in self.collection:
+            return self.collection[uuid]
+        return None
+
+    def persist(
+        self,
+        instance: ProcessingCase,
+        persist_items: bool = False,
+        view_format: DocumentViewFormat = DocumentViewFormat.PUBLIC_URL,
+    ) -> ProcessingCase:
+        self.collection[instance.uuid] = instance
+        return instance
+
+    def remove(self, instance: ProcessingCase):
+        if instance.uuid in self.collection:
+            del self.collection[instance.uuid]
+        return None
+
+    def filter(self, filters: ProcessingCaseFilters) -> List[ProcessingCase]:
+        return []

documente_shared/infrastructure/repositories/mem_processing_case_item.py

@@ -0,0 +1,52 @@
+from dataclasses import dataclass
+from typing import List, Optional
+
+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.repositories.processing_case_item import ProcessingCaseItemRepository
+
+
+@dataclass
+class MemoryProcessingCaseItemRepository(ProcessingCaseItemRepository):
+    collection: dict[str, ProcessingCaseItem] = None
+
+    def __post_init__(self):
+        self.collection = self.collection or {}
+
+    def find(
+        self,
+        uuid: str,
+        read_items: bool = False,
+    ) -> Optional[ProcessingCaseItem]:
+        if uuid in self.collection:
+            return self.collection[uuid]
+        return None
+
+    def find_by_digest(
+        self,
+        digest: str,
+        read_bytes: bool = False
+    ) -> Optional[ProcessingCaseItem]:
+        for item in self.collection.values():
+            if item.digest == digest:
+                return item
+        return None
+
+
+    def persist(
+        self,
+        instance: ProcessingCaseItem,
+        read_bytes: bool = False,
+        persist_bytes: bool = False,
+    ) -> ProcessingCaseItem:
+        self.collection[instance.uuid] = instance
+        return instance
+
+    def remove(self, instance: ProcessingCaseItem):
+        if instance.uuid in self.collection:
+            del self.collection[instance.uuid]
+        return None
+
+    def filter(self, filters: ProcessingCaseItemFilters) -> List[ProcessingCaseItem]:
+        return []