documente_shared 0.1.2__tar.gz → 0.1.4__tar.gz

{documente_shared-0.1.2 → documente_shared-0.1.4}/PKG-INFO

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

{documente_shared-0.1.2 → documente_shared-0.1.4}/documente_shared/domain/entities.py

@@ -1,5 +1,6 @@
 from dataclasses import dataclass
 from datetime import datetime
+from decimal import Decimal
 from typing import Optional
 
 from documente_shared.domain.enums import DocumentProcessStatus
@@ -12,7 +13,7 @@ class DocumentProcess(object):
     file_path: str
     processed_csv_path: str
     processed_xlsx_path: str
-    processing_time: Optional[float] = None
+    processing_time: Optional[Decimal] = None
     enqueued_at: Optional[datetime] = None
     started_at: Optional[datetime] = None
     failed_at: Optional[datetime] = None
@@ -72,7 +73,10 @@ class DocumentProcess(object):
             'file_path': self.file_path,
             'processed_csv_path': self.processed_csv_path,
             'processed_xlsx_path': self.processed_xlsx_path,
-            'processing_time': self.processing_time,
+            'processing_time': (
+                str(self.processing_time)
+                if self.processing_time 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,
@@ -88,7 +92,7 @@ class DocumentProcess(object):
             processed_csv_path=data.get('processed_csv_path'),
             processed_xlsx_path=data.get('processed_xlsx_path'),
             processing_time=(
-                data.get('processing_time')
+                Decimal(data.get('processing_time'))
                 if data.get('processing_time') else None
             ),
             enqueued_at=(

{documente_shared-0.1.2 → documente_shared-0.1.4}/documente_shared/domain/repositories.py

@@ -10,5 +10,5 @@ class DocumentProcessRepository(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    def delete(self, instance: DocumentProcess):
+    def remove(self, instance: DocumentProcess):
         raise NotImplementedError

documente_shared-0.1.4/documente_shared/infrastructure/dynamo_repositories.py

@@ -0,0 +1,16 @@
+from documente_shared.domain.entities import DocumentProcess
+from documente_shared.domain.repositories import DocumentProcessRepository
+from documente_shared.infrastructure.dynamo_table import DynamoDBTable
+
+
+class DynamoDocumentProcessRepository(
+    DynamoDBTable,
+    DocumentProcessRepository,
+):
+
+    def persist(self, instance: DocumentProcess) -> DocumentProcess:
+        self.put(instance.to_dict)
+        return instance
+
+    def remove(self, instance: DocumentProcess):
+        self.delete(key={'digest': instance.digest})

documente_shared-0.1.4/documente_shared/infrastructure/dynamo_table.py

@@ -0,0 +1,75 @@
+from dataclasses import dataclass
+
+import boto3
+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: str):
+        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, target_value):
+        return self._table(
+            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-0.1.4/documente_shared/infrastructure/s3_bucket.py

@@ -0,0 +1,51 @@
+import boto3
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+def remove_none_values(data: dict) -> dict:  # noqa: WPS110
+    return {key: value for key, value in data.items() if value is not None}  # noqa: WPS110
+
+
+@dataclass
+class S3Bucket(object):
+    bucket_name: str
+
+    def __post_init__(self):
+        self._resource = boto3.resource('s3')
+
+    def get(self, file_name: str) -> Optional[dict]:
+        try:
+            return self._resource.Object(self.bucket_name, file_name).get()
+        except self._resource.meta.client.exceptions.NoSuchKey:
+            return None
+
+    def get_bytes(self, file_name: str) -> Optional[dict]:
+        file_context = self.get(file_name)
+        if not file_context:
+            return None
+        return (
+            file_context['Body'].read()
+            if 'Body' in file_context
+            else None
+        )
+
+    def upload(self, file_name, file_content, content_type: Optional[str] = None):
+        optional_params = {'ContentType': content_type}
+        return self._resource.Object(self.bucket_name, file_name).put(
+            Body=file_content,
+            **remove_none_values(optional_params),
+        )
+
+    def delete(self, file_name):
+        return self._resource.Object(self.bucket_name, file_name).delete()
+
+    def get_url(self, file_name):
+        return 'https://{bucket_url}.s3.amazonaws.com/{file_name}'.format(
+            bucket_url=self.bucket_name,
+            file_name=file_name,
+        )
+
+    def read(self, file_name):
+        return self.get(file_name)['Body'].read()

{documente_shared-0.1.2 → documente_shared-0.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "documente_shared"
-version = "0.1.2"
+version = "0.1.4"
 description = "Shared utilities for Documente AI projects"
 authors = ["Tech <tech@llamitai.com>"]
 license = "MIT"
@@ -12,4 +12,7 @@ boto3 = "^1.34.102"
 botocore = "^1.34.102"
 
 [tool.poetry.dev-dependencies]
-pytest = "^6.0"
+pytest = "^6.0"
+[tool.poetry.group.package.dependencies]
+ipdb = "^0.13.13"
+

documente_shared-0.1.2/documente_shared/infrastructure/dynamo_repositories.py

@@ -1,10 +0,0 @@
-from documente_shared.domain.entities import DocumentProcess
-from documente_shared.domain.repositories import DocumentProcessRepository
-
-
-class DynamoDocumentProcessRepository(DocumentProcessRepository):
-    def persist(self, instance: DocumentProcess) -> DocumentProcess:
-        pass
-
-    def delete(self, instance: DocumentProcess):
-        pass