documente_shared 0.1.33__tar.gz → 0.1.34__tar.gz

{documente_shared-0.1.33 → documente_shared-0.1.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: documente_shared
-Version: 0.1.33
+Version: 0.1.34
 Summary: Shared utilities for Documente AI projects
 License: MIT
 Author: Tech
@@ -13,6 +13,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: boto3 (>=1.34.102,<2.0.0)
 Requires-Dist: botocore (>=1.34.102,<2.0.0)
+Requires-Dist: sentry-sdk (>=1.0.0,<2.0.0)
 Description-Content-Type: text/markdown
 
 

{documente_shared-0.1.33 → documente_shared-0.1.34}/README.md

@@ -1,4 +1,4 @@
-
-# Documente Shared
-
-Utilidades para proyectos Documente AI
+
+# Documente Shared
+
+Utilidades para proyectos Documente AI

{documente_shared-0.1.33 → documente_shared-0.1.34}/documente_shared/application/digest.py

@@ -1,7 +1,7 @@
-import hashlib
-
-
-def get_file_digest(file_bytes: bytes) -> str:
-     sha256_hash = hashlib.sha256()
-     sha256_hash.update(file_bytes)
-     return sha256_hash.hexdigest()
+import hashlib
+
+
+def get_file_digest(file_bytes: bytes) -> str:
+     sha256_hash = hashlib.sha256()
+     sha256_hash.update(file_bytes)
+     return sha256_hash.hexdigest()

documente_shared-0.1.34/documente_shared/application/exceptions.py

@@ -0,0 +1,23 @@
+import sentry_sdk
+from functools import wraps
+from typing import Callable, Any, TypeVar
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+def initialize_sentry(dsn: str, environment: str = "dev") -> None:
+    if not sentry_sdk.Hub.current.client: 
+        sentry_sdk.init(
+            dsn=dsn,
+            environment=environment,
+        )
+
+def track_exceptions(func: F) -> F:
+    @wraps(func)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            sentry_sdk.capture_exception(e)
+            sentry_sdk.flush()
+            raise
+    return wrapper  # type: ignore

{documente_shared-0.1.33 → documente_shared-0.1.34}/documente_shared/application/time_utils.py

@@ -1,10 +1,10 @@
-from datetime import datetime
-from typing import Union
-
-
-def get_datetime_from_data(input_datetime: Union[datetime, str]):
-    if isinstance(input_datetime, datetime):
-        return input_datetime
-    elif isinstance(input_datetime, str):
-        return datetime.fromisoformat(input_datetime)
+from datetime import datetime
+from typing import Union
+
+
+def get_datetime_from_data(input_datetime: Union[datetime, str]):
+    if isinstance(input_datetime, datetime):
+        return input_datetime
+    elif isinstance(input_datetime, str):
+        return datetime.fromisoformat(input_datetime)
     return None

{documente_shared-0.1.33 → documente_shared-0.1.34}/documente_shared/domain/base_enum.py

@@ -1,54 +1,54 @@
-from enum import Enum
-from typing import Union, Optional
-
-
-class BaseEnum(Enum):
-    """Provides the common functionalties to multiple model choices."""
-
-    @classmethod
-    def get_members(cls):
-        return [tag for tag in cls if type(tag.value) in [int, str, float]]
-
-    @classmethod
-    def choices(cls):
-        """Generate choice options for models."""
-        return [
-            (option.value, option.value)
-            for option in cls
-            if type(option.value) in [int, str, float]
-        ]
-
-    @classmethod
-    def values(cls):
-        """Returns values from choices."""
-        return [option.value for option in cls]
-
-    def __str__(self):  # noqa: D105
-        return str(self.value)
-
-    def __repr__(self):
-        return self.__str__()
-
-    def __hash__(self):
-        return hash(self.value)
-
-    @classmethod
-    def as_list(cls):
-        """Returns properties as a list."""
-        return [
-            value
-            for key, value in cls.__dict__.items()
-            if isinstance(value, str) and not key.startswith('__')
-        ]
-
-    @classmethod
-    def from_value(
-        cls,
-        value: Union[str, int],
-    ) -> Optional['BaseEnum']:
-        for tag in cls:
-            if isinstance(tag.value, str) and str(tag.value).upper() == str(value).upper():
-                return tag
-            elif not isinstance(tag.value, str) and tag.value == value:
-                return tag
+from enum import Enum
+from typing import Union, Optional
+
+
+class BaseEnum(Enum):
+    """Provides the common functionalties to multiple model choices."""
+
+    @classmethod
+    def get_members(cls):
+        return [tag for tag in cls if type(tag.value) in [int, str, float]]
+
+    @classmethod
+    def choices(cls):
+        """Generate choice options for models."""
+        return [
+            (option.value, option.value)
+            for option in cls
+            if type(option.value) in [int, str, float]
+        ]
+
+    @classmethod
+    def values(cls):
+        """Returns values from choices."""
+        return [option.value for option in cls]
+
+    def __str__(self):  # noqa: D105
+        return str(self.value)
+
+    def __repr__(self):
+        return self.__str__()
+
+    def __hash__(self):
+        return hash(self.value)
+
+    @classmethod
+    def as_list(cls):
+        """Returns properties as a list."""
+        return [
+            value
+            for key, value in cls.__dict__.items()
+            if isinstance(value, str) and not key.startswith('__')
+        ]
+
+    @classmethod
+    def from_value(
+        cls,
+        value: Union[str, int],
+    ) -> Optional['BaseEnum']:
+        for tag in cls:
+            if isinstance(tag.value, str) and str(tag.value).upper() == str(value).upper():
+                return tag
+            elif not isinstance(tag.value, str) and tag.value == value:
+                return tag
         return None

{documente_shared-0.1.33 → documente_shared-0.1.34}/documente_shared/domain/entities/document_process.py

@@ -1,199 +1,199 @@
-from dataclasses import dataclass
-from datetime import datetime
-from decimal import Decimal
-from typing import Optional, List
-
-from documente_shared.application.time_utils import get_datetime_from_data
-from documente_shared.domain.entities.document_process_metadata import DocumentProcessMetadata
-from documente_shared.domain.enums import (
-    DocumentProcessStatus,
-    DocumentProcessSubCategory,
-    DocumentProcessCategory,
-)
-
-def remove_slash_from_path(path: str) -> str:
-    if path and path.startswith('/'):
-        return path[1:]
-    return path
-
-@dataclass
-class DocumentProcess(object):
-    digest: str
-    status: DocumentProcessStatus
-    file_path: Optional[str] = None
-    file_bytes: Optional[bytes] = None
-    category: Optional[DocumentProcessCategory] = None
-    sub_category: Optional[DocumentProcessSubCategory] = None
-    processed_csv_path: Optional[str] = None
-    processed_csv_bytes: Optional[bytes] = None
-    processed_xlsx_path: Optional[str] = None
-    processed_xlsx_bytes: Optional[bytes] = None
-    processed_metadata_path: Optional[str] = None
-    processing_time: Optional[Decimal] = None
-    uploaded_at: Optional[datetime] = None
-    enqueued_at: Optional[datetime] = None
-    started_at: Optional[datetime] = None
-    failed_at: Optional[datetime] = None
-    completed_at: Optional[datetime] = None
-    metadata_items: Optional[List[DocumentProcessMetadata]] = None
-
-    def __post_init__(self):
-        self.metadata_items = self.metadata_items or []
-
-    @property
-    def is_pending(self) -> bool:
-        return self.status == DocumentProcessStatus.PENDING
-
-    @property
-    def is_enqueued(self) -> bool:
-        return self.status == DocumentProcessStatus.ENQUEUED
-
-    @property
-    def is_processing(self) -> bool:
-        return self.status == DocumentProcessStatus.PROCESSING
-
-    @property
-    def is_completed(self) -> bool:
-        return self.status == DocumentProcessStatus.COMPLETED
-
-    @property
-    def is_failed(self) -> bool:
-        return self.status == DocumentProcessStatus.FAILED
-
-    @property
-    def is_valid(self) -> bool:
-        return all([
-            self.digest,
-            self.status,
-            self.file_path,
-        ])
-
-    def enqueue(self):
-        self.status = DocumentProcessStatus.ENQUEUED
-        self.enqueued_at = datetime.now()
-
-    def processing(self):
-        self.status = DocumentProcessStatus.PROCESSING
-        self.started_at = datetime.now()
-
-    def failed(self):
-        self.status = DocumentProcessStatus.FAILED
-        self.failed_at = datetime.now()
-
-    def completed(self):
-        self.status = DocumentProcessStatus.COMPLETED
-        self.completed_at = datetime.now()
-
-    def deleted(self):
-        self.status = DocumentProcessStatus.DELETED
-
-    @property
-    def file_key(self) -> str:
-        return remove_slash_from_path(self.file_path)
-
-    @property
-    def processed_csv_key(self) -> str:
-        return remove_slash_from_path(self.processed_csv_path)
-
-    @property
-    def processed_xlsx_key(self) -> str:
-        return remove_slash_from_path(self.processed_xlsx_path)
-
-    @property
-    def processed_metadata_key(self) -> str:
-        return remove_slash_from_path(self.processed_metadata_path)
-
-    @property
-    def extended_filename(self) -> str:
-        return self.file_path.split('/')[-1]
-
-    @property
-    def filename(self) -> str:
-        filename_with_extension = self.extended_filename
-        return filename_with_extension.split('.')[0]
-
-    @property
-    def to_dict(self) -> dict:
-        return {
-            'digest': self.digest,
-            'status': str(self.status),
-            'file_path': self.file_path,
-            'category': (
-                str(self.category)
-                if self.category else None
-            ),
-            'sub_category': (
-                str(self.sub_category)
-                if self.sub_category else None
-            ),
-            'processed_csv_path': self.processed_csv_path,
-            'processed_xlsx_path': self.processed_xlsx_path,
-            'processed_metadata_path': self.processed_metadata_path,
-            'processing_time': (
-                str(self.processing_time.quantize(Decimal('0.00001')))
-                if self.processing_time else None
-            ),
-            'uploaded_at': self.uploaded_at.isoformat() if self.uploaded_at 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,
-            'completed_at': self.completed_at.isoformat() if self.completed_at else None,
-            'metadata_items': [metadata.to_dict for metadata in self.metadata_items],
-        }
-
-    @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: 'DocumentProcess',
-        properties: List[str] = None,
-    ):
-        instance_properties = properties or [
-            'status', 'metadata', 'file_path', 'file_bytes', 'category', 'sub_category',
-            'processed_csv_path', 'processed_csv_bytes', 'processed_xlsx_path', 'processed_metadata_path',
-            'processed_xlsx_bytes', 'processing_time', 'uploaded_at',
-            'enqueued_at', 'started_at', 'failed_at', 'completed_at',
-        ]
-        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) -> 'DocumentProcess':
-        return cls(
-            digest=data.get('digest'),
-            status=DocumentProcessStatus.from_value(data.get('status')),
-            file_path=data.get('file_path'),
-            category=(
-                DocumentProcessCategory.from_value(data.get('category'))
-                if data.get('category') else None
-            ),
-            sub_category=(
-                DocumentProcessSubCategory.from_value(data.get('sub_category'))
-                if data.get('sub_category') else None
-            ),
-            processed_csv_path=data.get('processed_csv_path'),
-            processed_xlsx_path=data.get('processed_xlsx_path'),
-            processed_metadata_path=data.get('processed_metadata_path'),
-            processing_time=(
-                Decimal(data.get('processing_time'))
-                if data.get('processing_time') else None
-            ),
-            uploaded_at=get_datetime_from_data(input_datetime=data.get('uploaded_at')),
-            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')),
-            completed_at=get_datetime_from_data(input_datetime=data.get('completed_at')),
-            metadata_items=[
-                DocumentProcessMetadata.from_dict(metadata)
-                for metadata in data.get('metadata_items', [])
-            ],
-        )
-
+from dataclasses import dataclass
+from datetime import datetime
+from decimal import Decimal
+from typing import Optional, List
+
+from documente_shared.application.time_utils import get_datetime_from_data
+from documente_shared.domain.entities.document_process_metadata import DocumentProcessMetadata
+from documente_shared.domain.enums import (
+    DocumentProcessStatus,
+    DocumentProcessSubCategory,
+    DocumentProcessCategory,
+)
+
+def remove_slash_from_path(path: str) -> str:
+    if path and path.startswith('/'):
+        return path[1:]
+    return path
+
+@dataclass
+class DocumentProcess(object):
+    digest: str
+    status: DocumentProcessStatus
+    file_path: Optional[str] = None
+    file_bytes: Optional[bytes] = None
+    category: Optional[DocumentProcessCategory] = None
+    sub_category: Optional[DocumentProcessSubCategory] = None
+    processed_csv_path: Optional[str] = None
+    processed_csv_bytes: Optional[bytes] = None
+    processed_xlsx_path: Optional[str] = None
+    processed_xlsx_bytes: Optional[bytes] = None
+    processed_metadata_path: Optional[str] = None
+    processing_time: Optional[Decimal] = None
+    uploaded_at: Optional[datetime] = None
+    enqueued_at: Optional[datetime] = None
+    started_at: Optional[datetime] = None
+    failed_at: Optional[datetime] = None
+    completed_at: Optional[datetime] = None
+    metadata_items: Optional[List[DocumentProcessMetadata]] = None
+
+    def __post_init__(self):
+        self.metadata_items = self.metadata_items or []
+
+    @property
+    def is_pending(self) -> bool:
+        return self.status == DocumentProcessStatus.PENDING
+
+    @property
+    def is_enqueued(self) -> bool:
+        return self.status == DocumentProcessStatus.ENQUEUED
+
+    @property
+    def is_processing(self) -> bool:
+        return self.status == DocumentProcessStatus.PROCESSING
+
+    @property
+    def is_completed(self) -> bool:
+        return self.status == DocumentProcessStatus.COMPLETED
+
+    @property
+    def is_failed(self) -> bool:
+        return self.status == DocumentProcessStatus.FAILED
+
+    @property
+    def is_valid(self) -> bool:
+        return all([
+            self.digest,
+            self.status,
+            self.file_path,
+        ])
+
+    def enqueue(self):
+        self.status = DocumentProcessStatus.ENQUEUED
+        self.enqueued_at = datetime.now()
+
+    def processing(self):
+        self.status = DocumentProcessStatus.PROCESSING
+        self.started_at = datetime.now()
+
+    def failed(self):
+        self.status = DocumentProcessStatus.FAILED
+        self.failed_at = datetime.now()
+
+    def completed(self):
+        self.status = DocumentProcessStatus.COMPLETED
+        self.completed_at = datetime.now()
+
+    def deleted(self):
+        self.status = DocumentProcessStatus.DELETED
+
+    @property
+    def file_key(self) -> str:
+        return remove_slash_from_path(self.file_path)
+
+    @property
+    def processed_csv_key(self) -> str:
+        return remove_slash_from_path(self.processed_csv_path)
+
+    @property
+    def processed_xlsx_key(self) -> str:
+        return remove_slash_from_path(self.processed_xlsx_path)
+
+    @property
+    def processed_metadata_key(self) -> str:
+        return remove_slash_from_path(self.processed_metadata_path)
+
+    @property
+    def extended_filename(self) -> str:
+        return self.file_path.split('/')[-1]
+
+    @property
+    def filename(self) -> str:
+        filename_with_extension = self.extended_filename
+        return filename_with_extension.split('.')[0]
+
+    @property
+    def to_dict(self) -> dict:
+        return {
+            'digest': self.digest,
+            'status': str(self.status),
+            'file_path': self.file_path,
+            'category': (
+                str(self.category)
+                if self.category else None
+            ),
+            'sub_category': (
+                str(self.sub_category)
+                if self.sub_category else None
+            ),
+            'processed_csv_path': self.processed_csv_path,
+            'processed_xlsx_path': self.processed_xlsx_path,
+            'processed_metadata_path': self.processed_metadata_path,
+            'processing_time': (
+                str(self.processing_time.quantize(Decimal('0.00001')))
+                if self.processing_time else None
+            ),
+            'uploaded_at': self.uploaded_at.isoformat() if self.uploaded_at 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,
+            'completed_at': self.completed_at.isoformat() if self.completed_at else None,
+            'metadata_items': [metadata.to_dict for metadata in self.metadata_items],
+        }
+
+    @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: 'DocumentProcess',
+        properties: List[str] = None,
+    ):
+        instance_properties = properties or [
+            'status', 'metadata', 'file_path', 'file_bytes', 'category', 'sub_category',
+            'processed_csv_path', 'processed_csv_bytes', 'processed_xlsx_path', 'processed_metadata_path',
+            'processed_xlsx_bytes', 'processing_time', 'uploaded_at',
+            'enqueued_at', 'started_at', 'failed_at', 'completed_at',
+        ]
+        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) -> 'DocumentProcess':
+        return cls(
+            digest=data.get('digest'),
+            status=DocumentProcessStatus.from_value(data.get('status')),
+            file_path=data.get('file_path'),
+            category=(
+                DocumentProcessCategory.from_value(data.get('category'))
+                if data.get('category') else None
+            ),
+            sub_category=(
+                DocumentProcessSubCategory.from_value(data.get('sub_category'))
+                if data.get('sub_category') else None
+            ),
+            processed_csv_path=data.get('processed_csv_path'),
+            processed_xlsx_path=data.get('processed_xlsx_path'),
+            processed_metadata_path=data.get('processed_metadata_path'),
+            processing_time=(
+                Decimal(data.get('processing_time'))
+                if data.get('processing_time') else None
+            ),
+            uploaded_at=get_datetime_from_data(input_datetime=data.get('uploaded_at')),
+            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')),
+            completed_at=get_datetime_from_data(input_datetime=data.get('completed_at')),
+            metadata_items=[
+                DocumentProcessMetadata.from_dict(metadata)
+                for metadata in data.get('metadata_items', [])
+            ],
+        )
+

{documente_shared-0.1.33 → documente_shared-0.1.34}/documente_shared/domain/entities/document_process_metadata.py

@@ -1,65 +1,65 @@
-from dataclasses import dataclass
-from datetime import datetime
-from typing import Optional
-
-
-@dataclass
-class DocumentProcessMetadata(object):
-    publication_date: Optional[datetime] = None
-    num_circular: Optional[str] = None
-    asfi_identifier: Optional[str] = None
-    contains_tables: Optional[bool] = None
-    text_content: Optional[str] = None
-    case_name: Optional[str] = None
-    starting_office: Optional[str] = None
-    output_json: Optional[dict] = None
-    processing_time: Optional[float] = None
-    llm_model: Optional[str] = None
-    num_pages: Optional[float] = None
-    num_tokens: Optional[float] = None
-    citcular_type: Optional[str] = None
-
-
-    @property
-    def to_dict(self):
-        return {
-            'publication_date': (
-                self.publication_date.isoformat()
-                if self.publication_date
-                else None
-            ),
-            'num_circular': self.num_circular,
-            'asfi_identifier': self.asfi_identifier,
-            'contains_tables': self.contains_tables,
-            'text_content': self.text_content,
-            'case_name': self.case_name,
-            'starting_office': self.starting_office,
-            'output_json': self.output_json,
-            'processing_time': self.processing_time,
-            'llm_model': self.llm_model,
-            'num_pages': self.num_pages,
-            'num_tokens': self.num_tokens,
-            'citcular_type': self.citcular_type
-        }
-
-    @classmethod
-    def from_dict(cls, data: dict):
-        return cls(
-            publication_date=(
-                datetime.fromisoformat(data.get('publication_date'))
-                if data.get('publication_date')
-                else None
-            ),
-            num_circular=data.get('num_circular'),
-            asfi_identifier=data.get('asfi_identifier'),
-            contains_tables=data.get('contains_tables'),
-            text_content=data.get('text_content'),
-            case_name=data.get('case_name'),
-            starting_office=data.get('starting_office'),
-            output_json=data.get('output_json'),
-            processing_time=data.get('processing_time'),
-            llm_model=data.get('llm_model'),
-            num_pages=data.get('num_pages'),
-            num_tokens=data.get('num_tokens'),
-            citcular_type=data.get('citcular_type')
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional
+
+
+@dataclass
+class DocumentProcessMetadata(object):
+    publication_date: Optional[datetime] = None
+    num_circular: Optional[str] = None
+    asfi_identifier: Optional[str] = None
+    contains_tables: Optional[bool] = None
+    text_content: Optional[str] = None
+    case_name: Optional[str] = None
+    starting_office: Optional[str] = None
+    output_json: Optional[dict] = None
+    processing_time: Optional[float] = None
+    llm_model: Optional[str] = None
+    num_pages: Optional[float] = None
+    num_tokens: Optional[float] = None
+    citcular_type: Optional[str] = None
+
+
+    @property
+    def to_dict(self):
+        return {
+            'publication_date': (
+                self.publication_date.isoformat()
+                if self.publication_date
+                else None
+            ),
+            'num_circular': self.num_circular,
+            'asfi_identifier': self.asfi_identifier,
+            'contains_tables': self.contains_tables,
+            'text_content': self.text_content,
+            'case_name': self.case_name,
+            'starting_office': self.starting_office,
+            'output_json': self.output_json,
+            'processing_time': self.processing_time,
+            'llm_model': self.llm_model,
+            'num_pages': self.num_pages,
+            'num_tokens': self.num_tokens,
+            'citcular_type': self.citcular_type
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(
+            publication_date=(
+                datetime.fromisoformat(data.get('publication_date'))
+                if data.get('publication_date')
+                else None
+            ),
+            num_circular=data.get('num_circular'),
+            asfi_identifier=data.get('asfi_identifier'),
+            contains_tables=data.get('contains_tables'),
+            text_content=data.get('text_content'),
+            case_name=data.get('case_name'),
+            starting_office=data.get('starting_office'),
+            output_json=data.get('output_json'),
+            processing_time=data.get('processing_time'),
+            llm_model=data.get('llm_model'),
+            num_pages=data.get('num_pages'),
+            num_tokens=data.get('num_tokens'),
+            citcular_type=data.get('citcular_type')
         )

{documente_shared-0.1.33 → documente_shared-0.1.34}/documente_shared/domain/enums.py

@@ -1,22 +1,22 @@
-from documente_shared.domain.base_enum import BaseEnum
-
-
-class DocumentProcessStatus(BaseEnum):
-    PENDING = 'PENDING'
-    ENQUEUED = 'ENQUEUED'
-    PROCESSING = 'PROCESSING'
-    COMPLETED = 'COMPLETED'
-    FAILED = 'FAILED'
-    DELETED = 'DELETED'
-    CANCELLED = 'CANCELLED'
-
-
-class DocumentProcessCategory(BaseEnum):
-    CIRCULAR = 'CIRCULAR'
-
-
-class DocumentProcessSubCategory(BaseEnum):
-    CC_COMBINADA = 'CC_COMBINADA'
-    CC_NORMATIVA = 'CC_NORMATIVA'
-
-
+from documente_shared.domain.base_enum import BaseEnum
+
+
+class DocumentProcessStatus(BaseEnum):
+    PENDING = 'PENDING'
+    ENQUEUED = 'ENQUEUED'
+    PROCESSING = 'PROCESSING'
+    COMPLETED = 'COMPLETED'
+    FAILED = 'FAILED'
+    DELETED = 'DELETED'
+    CANCELLED = 'CANCELLED'
+
+
+class DocumentProcessCategory(BaseEnum):
+    CIRCULAR = 'CIRCULAR'
+
+
+class DocumentProcessSubCategory(BaseEnum):
+    CC_COMBINADA = 'CC_COMBINADA'
+    CC_NORMATIVA = 'CC_NORMATIVA'
+
+

{documente_shared-0.1.33 → documente_shared-0.1.34}/documente_shared/domain/repositories.py

@@ -1,19 +1,19 @@
-from abc import ABC, abstractmethod
-from typing import Optional
-
-from documente_shared.domain.entities.document_process import DocumentProcess
-
-
-class DocumentProcessRepository(ABC):
-
-    @abstractmethod
-    def find(self, digest: str) ->Optional[DocumentProcess]:
-        raise NotImplementedError
-
-    @abstractmethod
-    def persist(self, instance: DocumentProcess) -> DocumentProcess:
-        raise NotImplementedError
-
-    @abstractmethod
-    def remove(self, instance: DocumentProcess):
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from documente_shared.domain.entities.document_process import DocumentProcess
+
+
+class DocumentProcessRepository(ABC):
+
+    @abstractmethod
+    def find(self, digest: str) ->Optional[DocumentProcess]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def persist(self, instance: DocumentProcess) -> DocumentProcess:
+        raise NotImplementedError
+
+    @abstractmethod
+    def remove(self, instance: DocumentProcess):
         raise NotImplementedError

{documente_shared-0.1.33 → documente_shared-0.1.34}/documente_shared/infrastructure/dynamo_repositories.py

@@ -1,24 +1,24 @@
-from typing import Optional
-
-from documente_shared.domain.entities.document_process import DocumentProcess
-from documente_shared.domain.repositories import DocumentProcessRepository
-from documente_shared.infrastructure.dynamo_table import DynamoDBTable
-
-
-
-class DynamoDocumentProcessRepository(
-    DynamoDBTable,
-    DocumentProcessRepository,
-):
-    def find(self, digest: str) -> Optional[DocumentProcess]:
-        item = self.get(key={'digest': digest})
-        if item:
-            return DocumentProcess.from_dict(item)
-        return None
-
-    def persist(self, instance: DocumentProcess) -> DocumentProcess:
-        self.put(instance.to_simple_dict)
-        return instance
-
-    def remove(self, instance: DocumentProcess):
+from typing import Optional
+
+from documente_shared.domain.entities.document_process import DocumentProcess
+from documente_shared.domain.repositories import DocumentProcessRepository
+from documente_shared.infrastructure.dynamo_table import DynamoDBTable
+
+
+
+class DynamoDocumentProcessRepository(
+    DynamoDBTable,
+    DocumentProcessRepository,
+):
+    def find(self, digest: str) -> Optional[DocumentProcess]:
+        item = self.get(key={'digest': digest})
+        if item:
+            return DocumentProcess.from_dict(item)
+        return None
+
+    def persist(self, instance: DocumentProcess) -> DocumentProcess:
+        self.put(instance.to_simple_dict)
+        return instance
+
+    def remove(self, instance: DocumentProcess):
         self.delete(key={'digest': instance.digest})

{documente_shared-0.1.33 → documente_shared-0.1.34}/documente_shared/infrastructure/dynamo_table.py

@@ -1,75 +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: 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, 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()
-        }
+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: 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, 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.33 → documente_shared-0.1.34}/documente_shared/infrastructure/s3_bucket.py

@@ -1,57 +1,57 @@
-import boto3
-
-from dataclasses import dataclass
-from typing import Optional
-
-from documente_shared.domain.entities.document_process import remove_slash_from_path
-
-
-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_key: str) -> Optional[dict]:
-        try:
-            return self._resource.Object(self.bucket_name, file_key).get()
-        except self._resource.meta.client.exceptions.NoSuchKey:
-            return None
-
-    def get_bytes(self, file_key: str) -> Optional[bytes]:
-        cleaned_file_key = remove_slash_from_path(file_key)
-        file_context = self.get(cleaned_file_key)
-        if not file_context:
-            return None
-        return (
-            file_context['Body'].read()
-            if 'Body' in file_context
-            else None
-        )
-
-    def upload(self, file_key: str, file_content, content_type: Optional[str] = None):
-        cleaned_file_key = remove_slash_from_path(file_key)
-        optional_params = {'ContentType': content_type}
-        return self._resource.Object(self.bucket_name, cleaned_file_key).put(
-            Body=file_content,
-            **remove_none_values(optional_params),
-        )
-
-    def delete(self, file_key: str):
-        cleaned_file_key = remove_slash_from_path(file_key)
-        return self._resource.Object(self.bucket_name, cleaned_file_key).delete()
-
-    def get_url(self, file_key: str):
-        cleaned_file_key = remove_slash_from_path(file_key)
-        return 'https://{bucket_url}.s3.amazonaws.com/{file_key}'.format(
-            bucket_url=self.bucket_name,
-            file_key=cleaned_file_key,
-        )
-
-    def read(self, file_key: str) -> bytes:
-        return self.get(file_key)['Body'].read()
+import boto3
+
+from dataclasses import dataclass
+from typing import Optional
+
+from documente_shared.domain.entities.document_process import remove_slash_from_path
+
+
+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_key: str) -> Optional[dict]:
+        try:
+            return self._resource.Object(self.bucket_name, file_key).get()
+        except self._resource.meta.client.exceptions.NoSuchKey:
+            return None
+
+    def get_bytes(self, file_key: str) -> Optional[bytes]:
+        cleaned_file_key = remove_slash_from_path(file_key)
+        file_context = self.get(cleaned_file_key)
+        if not file_context:
+            return None
+        return (
+            file_context['Body'].read()
+            if 'Body' in file_context
+            else None
+        )
+
+    def upload(self, file_key: str, file_content, content_type: Optional[str] = None):
+        cleaned_file_key = remove_slash_from_path(file_key)
+        optional_params = {'ContentType': content_type}
+        return self._resource.Object(self.bucket_name, cleaned_file_key).put(
+            Body=file_content,
+            **remove_none_values(optional_params),
+        )
+
+    def delete(self, file_key: str):
+        cleaned_file_key = remove_slash_from_path(file_key)
+        return self._resource.Object(self.bucket_name, cleaned_file_key).delete()
+
+    def get_url(self, file_key: str):
+        cleaned_file_key = remove_slash_from_path(file_key)
+        return 'https://{bucket_url}.s3.amazonaws.com/{file_key}'.format(
+            bucket_url=self.bucket_name,
+            file_key=cleaned_file_key,
+        )
+
+    def read(self, file_key: str) -> bytes:
+        return self.get(file_key)['Body'].read()

{documente_shared-0.1.33 → documente_shared-0.1.34}/documente_shared/infrastructure/sqs_queue.py

@@ -1,48 +1,48 @@
-import json
-import boto3
-
-from dataclasses import dataclass
-
-
-@dataclass
-class SQSQueue(object):
-    queue_url: str
-    visibility_timeout: int =  60 * 10
-    waiting_timeout: int = 20
-
-    def __post_init__(self):
-        self._client = boto3.client('sqs')
-
-    def send_message(
-        self,
-        payload: dict,
-        message_attributes: dict = None,
-        delay_seconds: dict = None,
-        message_group_id: dict = None,
-        message_deduplication_id: dict =None,
-    ):
-        message_params = {
-            'QueueUrl': self.queue_url,
-            'MessageBody': json.dumps(payload),
-            'MessageAttributes': message_attributes,
-            'DelaySeconds': delay_seconds,
-            'MessageGroupId': message_group_id,
-            'MessageDeduplicationId': message_deduplication_id,
-        }
-        clean_params = {key: value for key, value in message_params.items() if value}
-        return self._client.send_message(**clean_params)
-
-    def delete_message(self, receipt_handle: str):
-        return self._client.delete_message(
-            QueueUrl=self.queue_url,
-            ReceiptHandle=receipt_handle
-        )
-
-    def fetch_messages(self, num_messages: int = 1) -> list[dict]:
-        response = self._client.receive_message(
-            QueueUrl=self.queue_url,
-            MaxNumberOfMessages=num_messages,
-            VisibilityTimeout=self.visibility_timeout,
-            WaitTimeSeconds=self.waiting_timeout,
-        )
+import json
+import boto3
+
+from dataclasses import dataclass
+
+
+@dataclass
+class SQSQueue(object):
+    queue_url: str
+    visibility_timeout: int =  60 * 10
+    waiting_timeout: int = 20
+
+    def __post_init__(self):
+        self._client = boto3.client('sqs')
+
+    def send_message(
+        self,
+        payload: dict,
+        message_attributes: dict = None,
+        delay_seconds: dict = None,
+        message_group_id: dict = None,
+        message_deduplication_id: dict =None,
+    ):
+        message_params = {
+            'QueueUrl': self.queue_url,
+            'MessageBody': json.dumps(payload),
+            'MessageAttributes': message_attributes,
+            'DelaySeconds': delay_seconds,
+            'MessageGroupId': message_group_id,
+            'MessageDeduplicationId': message_deduplication_id,
+        }
+        clean_params = {key: value for key, value in message_params.items() if value}
+        return self._client.send_message(**clean_params)
+
+    def delete_message(self, receipt_handle: str):
+        return self._client.delete_message(
+            QueueUrl=self.queue_url,
+            ReceiptHandle=receipt_handle
+        )
+
+    def fetch_messages(self, num_messages: int = 1) -> list[dict]:
+        response = self._client.receive_message(
+            QueueUrl=self.queue_url,
+            MaxNumberOfMessages=num_messages,
+            VisibilityTimeout=self.visibility_timeout,
+            WaitTimeSeconds=self.waiting_timeout,
+        )
         return response.get('Messages', [])

{documente_shared-0.1.33 → documente_shared-0.1.34}/pyproject.toml

@@ -1,18 +1,19 @@
-[tool.poetry]
-name = "documente_shared"
-version = "0.1.33"
-description = "Shared utilities for Documente AI projects"
-authors = ["Tech <tech@llamitai.com>"]
-license = "MIT"
-readme = "README.md"
-
-[tool.poetry.dependencies]
-python = ">=3.10,<3.13"
-boto3 = "^1.34.102"
-botocore = "^1.34.102"
-
-[tool.poetry.dev-dependencies]
-pytest = "^6.0"
-[tool.poetry.group.package.dependencies]
-ipdb = "^0.13.13"
-
+[tool.poetry]
+name = "documente_shared"
+version = "0.1.34"
+description = "Shared utilities for Documente AI projects"
+authors = ["Tech <tech@llamitai.com>"]
+license = "MIT"
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = ">=3.10,<3.13"
+boto3 = "^1.34.102"
+botocore = "^1.34.102"
+sentry-sdk = "^1.0.0" 
+
+[tool.poetry.dev-dependencies]
+pytest = "^6.0"
+[tool.poetry.group.package.dependencies]
+ipdb = "^0.13.13"
+