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

documente_shared/infrastructure/dynamo_table.py

@@ -1,75 +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()
-        }
+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/repositories/dynamo_document.py

@@ -1,43 +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) -> Optional[DocumentProcessing]:
-        item = self.get(key={'digest': digest})
-        if item:
-            return DocumentProcessing.from_dict(item)
-        return None
-
-    def persist(self, instance: DocumentProcessing) -> 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
-        ]
+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) -> Optional[DocumentProcessing]:
+        item = self.get(key={'digest': digest})
+        if item:
+            return DocumentProcessing.from_dict(item)
+        return None
+
+    def persist(self, instance: DocumentProcessing) -> 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

@@ -1,43 +1,43 @@
-from typing import Optional, List
-
-from boto3.dynamodb.conditions import Key
-
-from documente_shared.domain.entities.processing_case import ProcessingCase
-from documente_shared.domain.enums.common import ProcessingStatus
-from documente_shared.domain.repositories.processing_case import ProcessingCaseRepository
-
-from documente_shared.infrastructure.dynamo_table import DynamoDBTable
-
-
-class DynamoProcessingCaseRepository(
-    DynamoDBTable,
-    ProcessingCaseRepository,
-):
-    def find(self, case_id: str) -> Optional[ProcessingCase]:
-        item = self.get(key={'case_id': case_id})
-        if item:
-            return ProcessingCase.from_dict(item)
-        return None
-
-    def persist(self, instance: ProcessingCase) -> ProcessingCase:
-        self.put(instance.to_persist_dict)
-        return instance
-
-    def remove(self, instance: ProcessingCase):
-        self.delete(key={'case_id': instance.case_id})
-
-    def filter(self, statuses: List[ProcessingStatus]) -> List[ProcessingCase]:
-        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 [
-            ProcessingCase.from_dict(item)
-            for item in items
-        ]
+from typing import Optional, List
+
+from boto3.dynamodb.conditions import Key
+
+from documente_shared.domain.entities.processing_case import ProcessingCase
+from documente_shared.domain.enums.common import ProcessingStatus
+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) -> Optional[ProcessingCase]:
+        item = self.get(key={'uuid': uuid})
+        if item:
+            return ProcessingCase.from_dict(item)
+        return None
+
+    def persist(self, instance: ProcessingCase) -> ProcessingCase:
+        self.put(instance.to_persist_dict)
+        return instance
+
+    def remove(self, instance: ProcessingCase):
+        self.delete(key={'uuid': instance.uuid})
+
+    def filter(self, statuses: List[ProcessingStatus]) -> List[ProcessingCase]:
+        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 [
+            ProcessingCase.from_dict(item)
+            for item in items
+        ]

documente_shared/infrastructure/repositories/dynamo_processing_case_item.py

@@ -1,54 +1,43 @@
-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.enums.common import ProcessingStatus
-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) -> Optional[ProcessingCaseItem]:
-        item = self.get(key={'digest': uuid})
-        if item:
-            return ProcessingCaseItem.from_dict(item)
-        return None
-
-    def persist(self, instance: ProcessingCaseItem) -> 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, statuses: List[ProcessingStatus]) -> List[ProcessingCaseItem]:
-        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 [
-            ProcessingCaseItem.from_dict(item)
-            for item in items
-        ]
-
-    def filter_by_case_id(self, case_id: str) -> List[ProcessingCaseItem]:
-        response = self._table.query(
-            IndexName='case_id',
-            KeyConditionExpression=Key('case_id').eq(case_id),
-        )
-        items = response.get('Items', [])
-        return [
-            ProcessingCaseItem.from_dict(item)
-            for item in items
-        ]
+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.enums.common import ProcessingStatus
+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) -> Optional[ProcessingCaseItem]:
+        item = self.get(key={'digest': uuid})
+        if item:
+            return ProcessingCaseItem.from_dict(item)
+        return None
+
+    def persist(self, instance: ProcessingCaseItem) -> 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, statuses: List[ProcessingStatus]) -> List[ProcessingCaseItem]:
+        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 [
+            ProcessingCaseItem.from_dict(item)
+            for item in items
+        ]

documente_shared/infrastructure/repositories/http_processing_case.py

@@ -1,41 +1,42 @@
-from dataclasses import dataclass
-from typing import List, Optional
-
-from documente_shared.domain.entities.processing_case import ProcessingCase
-from documente_shared.domain.enums.common import ProcessingStatus
-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, case_id: str) -> Optional[ProcessingCase]:
-        response = self.session.get(f"{self.base_url}/processing-cases/{case_id}/")
-        if response.status_code == 200:
-            return ProcessingCase.from_dict(response.json())
-        return None
-
-    def persist(self, instance: ProcessingCase) -> ProcessingCase:
-        response = self.session.put(
-            url=f"{self.base_url}/processing-cases/{instance.uuid}/",
-            json=instance.to_dict,
-        )
-        if response.status_code in [200, 201]:
-            return ProcessingCase.from_dict(response.json())
-        return instance
-
-    def remove(self, instance: ProcessingCase):
-        self.session.delete(f"{self.base_url}/processing-cases/{instance.uuid}/")
-
-    def filter(self, statuses: List[ProcessingStatus]) -> List[ProcessingCase]:
-        response = self.session.get(f"{self.base_url}/processing-cases/")
-        if response.status_code == 200:
-            raw_response = response.json()
-            return [
-                ProcessingCase.from_dict(item)
-                for item in raw_response.get('data', [])
-            ]
+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 ProcessingStatus
+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) -> Optional[ProcessingCase]:
+        response = self.session.get(f"{self.api_url}/processing-cases/{uuid}/")
+        if response.status_code == 200:
+            return ProcessingCase.from_dict(response.json())
+        return None
+
+    def persist(self, instance: ProcessingCase) -> ProcessingCase:
+        response = self.session.put(
+            url=f"{self.api_url}/processing-cases/{instance.uuid}/",
+            json=instance.to_dict,
+        )
+        if response.status_code not in [200, 201]:
+            raise Exception(f'Error persisting processing case: {response.text}')
+        return ProcessingCase.from_dict(response.json())
+
+    def remove(self, instance: ProcessingCase):
+        self.session.delete(f"{self.api_url}/processing-cases/{instance.uuid}/")
+
+    def filter(self, filters: ProcessingCaseFilters) -> List[ProcessingCase]:
+        response = self.session.get(f"{self.api_url}/processing-cases/")
+        if response.status_code == 200:
+            raw_response = response.json()
+            return [
+                ProcessingCase.from_dict(item)
+                for item in raw_response.get('data', [])
+            ]
         return []

documente_shared/infrastructure/repositories/http_processing_case_item.py

@@ -1,53 +1,43 @@
-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_item import ProcessingCaseItem
-from documente_shared.domain.enums.common import ProcessingStatus
-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) -> Optional[ProcessingCaseItem]:
-        response = self.session.get(f"{self.base_url}/processing-case-items/{uuid}/")
-        if response.status_code == 200:
-            return ProcessingCaseItem.from_dict(response.json())
-        return None
-
-    def persist(self, instance: ProcessingCaseItem) -> ProcessingCaseItem:
-        response = self.session.put(
-            url=f"{self.base_url}/processing-case-items/{instance.uuid}/",
-            json=instance.to_simple_dict,
-        )
-        if response.status_code in [200, 201]:
-            return ProcessingCaseItem.from_dict(response.json())
-        return instance
-
-    def remove(self, instance: ProcessingCaseItem):
-        self.session.delete(f"{self.base_url}/processing-case-items/{instance.uuid}/")
-
-    def filter(self, statuses: List[ProcessingStatus]) -> List[ProcessingCase]:
-        response = self.session.get(f"{self.base_url}/processing-case-items/")
-        if response.status_code == 200:
-            raw_response = response.json()
-            return [
-                ProcessingCase.from_dict(item)
-                for item in raw_response.get('data', [])
-            ]
-        return []
-
-    def filter_by_case_id(self, case_id: str) -> List[ProcessingCase]:
-        response = self.session.get(f"{self.base_url}/processing-case-items/?case_id={case_id}")
-        if response.status_code == 200:
-            raw_response = response.json()
-            return [
-                ProcessingCase.from_dict(item)
-                for item in raw_response.get('data', [])
-            ]
-        return []
+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_item import ProcessingCaseItem
+from documente_shared.domain.enums.common import ProcessingStatus
+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) -> Optional[ProcessingCaseItem]:
+        response = self.session.get(f"{self.api_url}/processing-case-items/{uuid}/")
+        if response.status_code == 200:
+            return ProcessingCaseItem.from_dict(response.json())
+        return None
+
+    def persist(self, instance: ProcessingCaseItem) -> ProcessingCaseItem:
+        response = self.session.put(
+            url=f"{self.api_url}/processing-case-items/{instance.uuid}/",
+            json=instance.to_simple_dict,
+        )
+        if response.status_code in [200, 201]:
+            return ProcessingCaseItem.from_dict(response.json())
+        return instance
+
+    def remove(self, instance: ProcessingCaseItem):
+        self.session.delete(f"{self.api_url}/processing-case-items/{instance.uuid}/")
+
+    def filter(self, statuses: List[ProcessingStatus]) -> List[ProcessingCase]:
+        response = self.session.get(f"{self.api_url}/processing-case-items/")
+        if response.status_code == 200:
+            raw_response = response.json()
+            return [
+                ProcessingCase.from_dict(item)
+                for item in raw_response.get('data', [])
+            ]
+        return []