documente_shared 0.1.73__tar.gz → 0.1.74__tar.gz

{documente_shared-0.1.73 → documente_shared-0.1.74}/PKG-INFO

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

documente_shared-0.1.74/documente_shared/application/query_params.py

@@ -0,0 +1,129 @@
+from documente_shared.domain.base_enum import BaseEnum
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import List, Optional, Type, Union
+from uuid import UUID
+
+
+
+def camelize_string(value: str) -> str:
+    if not value:
+        return value
+    value = "".join(word.title() for word in value.split("_"))
+    return value[:1].lower() + value[1:]
+
+
+@dataclass
+class QueryParams(object):
+    params: Union[dict]
+
+    def get(self, key, default=None):
+        return self.params.get(key, default) or self.params.get(camelize_string(key), default)
+
+    def get_datetime(self, key: str, default=None):
+        try:
+            value = self.get_str(key, default)
+            if not value:
+                return None
+            return datetime.strptime(value, "%Y-%m-%d")
+        except (ValueError, TypeError):
+            return None
+
+    def get_str(self, key, default=None):
+        try:
+            return self._get_or_none(key, str, default)
+        except (ValueError, TypeError):
+            return None
+
+    def get_int(self, key, default=None):
+        try:
+            return self._get_or_none(key, int, default)
+        except (ValueError, TypeError):
+            return None
+
+    def get_float(self, key, default=None):
+        try:
+            return self._get_or_none(key, float, default)
+        except (ValueError, TypeError):
+            return None
+
+    def get_bool(self, key, default=False):
+        try:
+            value = self.get(key, default)
+            if isinstance(value, bool):
+                return value
+            elif isinstance(value, str):
+                return value in ["true", "True", "TRUE", "1", "active"]
+            elif value is None:
+                return None
+            return False
+        except (ValueError, TypeError):
+            return None
+
+    def get_uuid(self, key, default=None):
+        try:
+            return self._get_or_none(key, UUID, default)
+        except (ValueError, TypeError):
+            return None
+
+    def get_uuid_list(self, key, default=None):
+        def parse_str(value):
+            uuid_list = []
+            for uuid_str in value.split(","):
+                try:
+                    uuid_list.append(UUID(uuid_str))
+                except ValueError:
+                    pass
+            return uuid_list
+
+        try:
+            return self._get_or_none(key, parse_str, default)
+        except (ValueError, TypeError):
+            return None
+
+    def get_list(self, key, default=None):
+        default = default or []
+        try:
+            return self.params.getlist(key) or self.params.getlist(camelize_string(key)) or default
+        except (ValueError, TypeError):
+            return None
+
+    def get_enum(
+        self,
+        key: str,
+        enum_class: Type[BaseEnum],
+        default: BaseEnum = None,
+    ) -> Optional[BaseEnum]:
+        try:
+            str_value = self.get_str(key) or default
+            return enum_class.from_value(str_value) if str_value else None
+        except (ValueError, TypeError):
+            return None
+
+    def get_enum_list(
+        self,
+        key: str,
+        enum_class: Type[BaseEnum],
+        default: BaseEnum = None,
+    ) -> List:
+        str_value = self.get_str(key) or default
+        if not str_value:
+            return []
+        converted_enum_list = []
+        str_enum_items = str_value.split(",")
+        for str_enum_item in str_enum_items:
+            enum_value = enum_class.from_value(value=str_enum_item)
+            if not enum_value:
+                continue
+            converted_enum_list.append(enum_value)
+        return converted_enum_list
+
+    def _get_or_none(
+        self,
+        key: str,
+        cast_type: Type[Union[str, int, float, bool, UUID]],
+        default=None,
+    ) -> Optional[Union[str, int, float, bool, UUID]]:
+        item_value = self.get(key, default)
+        return cast_type(item_value) if item_value else default

documente_shared-0.1.74/documente_shared/domain/entities/processing_case_filters.py

@@ -0,0 +1,48 @@
+from dataclasses import dataclass
+from datetime import datetime
+from typing import List, Optional
+
+from documente_shared.domain.enums.common import ProcessingStatus
+from documente_shared.domain.enums.processing_case import ProcessingCaseType
+from documente_shared.application.query_params import QueryParams
+
+
+@dataclass
+class ProcessingCaseFilters(object):
+    case_ids: Optional[List[str]]
+    sort_order: Optional[str]
+    search: Optional[str]
+    init_date: Optional[datetime]
+    end_date: Optional[datetime]
+    statuses: List[ProcessingStatus] = None
+    case_types: List[ProcessingCaseType] = None
+    include_archived: bool = False
+
+    def __post_init__(self):
+        self.statuses = self.statuses or []
+        self.case_types = self.case_types or []
+
+    @classmethod
+    def from_params(cls, params: QueryParams) -> "ProcessingCaseFilters":
+        search_term = params.get_str(key="search", default=None)
+        return ProcessingCaseFilters(
+            case_ids=params.get_uuid_list(key="case_ids", default=None),
+            sort_order=params.get(key="sort", default="desc"),
+            search=search_term.strip() if search_term else None,
+            init_date=params.get_datetime(key="init_date", default=None),
+            end_date=params.get_datetime(key="end_date", default=None),
+            statuses=params.get_enum_list(
+                key="statuses",
+                enum_class=ProcessingStatus,
+                default=None,
+            ),
+            case_types=params.get_enum_list(
+                key="case_types",
+                enum_class=ProcessingCaseType,
+                default=None,
+            ),
+            include_archived=params.get_bool(
+                key="include_archived",
+                default=False,
+            ),
+        )

documente_shared-0.1.74/documente_shared/domain/entities/processing_case_item_filters.py

@@ -0,0 +1,51 @@
+from dataclasses import dataclass
+from datetime import datetime
+from typing import List, Optional
+
+from documente_shared.application.query_params import QueryParams
+from documente_shared.domain.enums.common import ProcessingStatus
+from documente_shared.domain.enums.document import (
+    DocumentProcessingStatus,
+)
+from documente_shared.domain.enums.processing_case import ProcessingDocumentType
+
+
+@dataclass
+class ProcessingCaseItemFilters(object):
+    sort_order: Optional[str]
+    search: Optional[str]
+    init_date: Optional[datetime]
+    end_date: Optional[datetime]
+    case_id: Optional[str] = None
+    statuses: List[ProcessingStatus] = None
+    document_types: List[ProcessingDocumentType] = None
+    include_archived: bool = False
+
+    def __post_init__(self):
+        self.statuses = self.statuses or []
+        self.document_types = self.document_types or []
+
+    @classmethod
+    def from_params(cls, params: QueryParams) -> "ProcessingCaseItemFilters":
+        search_term = params.get_str(key="search", default=None)
+        return cls(
+            sort_order=params.get(key="sort", default="desc"),
+            search=search_term.strip() if search_term else None,
+            init_date=params.get_datetime(key="init_date", default=None),
+            end_date=params.get_datetime(key="end_date", default=None),
+            case_id=params.get_str(key="case_id", default=None),
+            statuses=params.get_enum_list(
+                key="statuses",
+                enum_class=DocumentProcessingStatus,
+                default=None,
+            ),
+            document_types=params.get_enum_list(
+                key="document_types",
+                enum_class=ProcessingDocumentType,
+                default=None,
+            ),
+            include_archived=params.get_bool(
+                key="include_archived",
+                default=False,
+            ),
+        )

{documente_shared-0.1.73 → documente_shared-0.1.74}/documente_shared/domain/repositories/processing_case.py

@@ -2,7 +2,7 @@ from abc import ABC, abstractmethod
 from typing import Optional, List
 
 from documente_shared.domain.entities.processing_case import ProcessingCase
-from documente_shared.domain.enums.common import ProcessingStatus
+from documente_shared.domain.entities.processing_case_filters import ProcessingCaseFilters
 
 
 class ProcessingCaseRepository(ABC):
@@ -20,5 +20,5 @@ class ProcessingCaseRepository(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    def filter(self, statuses: List[ProcessingStatus]) -> List[ProcessingCase]:
+    def filter(self, filters: ProcessingCaseFilters) -> List[ProcessingCase]:
         raise NotImplementedError

{documente_shared-0.1.73 → documente_shared-0.1.74}/documente_shared/domain/repositories/processing_case_item.py

@@ -3,7 +3,7 @@ from typing import Optional, List
 
 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.entities.processing_case_item_filters import ProcessingCaseItemFilters
 
 
 class ProcessingCaseItemRepository(ABC):
@@ -21,9 +21,5 @@ class ProcessingCaseItemRepository(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    def filter(self, statuses: List[ProcessingStatus]) -> List[ProcessingCase]:
-        raise NotImplementedError
-
-    @abstractmethod
-    def filter_by_case_id(self, case_id: str) -> List[ProcessingCase]:
+    def filter(self, filters: ProcessingCaseItemFilters) -> List[ProcessingCase]:
         raise NotImplementedError

{documente_shared-0.1.73 → documente_shared-0.1.74}/documente_shared/infrastructure/repositories/dynamo_processing_case_item.py

@@ -41,14 +41,3 @@ class DynamoProcessingCaseItemRepository(
             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
-        ]

{documente_shared-0.1.73 → documente_shared-0.1.74}/documente_shared/infrastructure/repositories/http_processing_case.py

@@ -2,6 +2,7 @@ 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
@@ -30,7 +31,7 @@ class HttpProcessingCaseRepository(
     def remove(self, instance: ProcessingCase):
         self.session.delete(f"{self.api_url}/processing-cases/{instance.uuid}/")
 
-    def filter(self, statuses: List[ProcessingStatus]) -> List[ProcessingCase]:
+    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()

{documente_shared-0.1.73 → documente_shared-0.1.74}/documente_shared/infrastructure/repositories/http_processing_case_item.py

@@ -41,13 +41,3 @@ class HttpProcessingCaseItemRepository(
                 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.api_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 []

{documente_shared-0.1.73 → documente_shared-0.1.74}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "documente_shared"
-version = "0.1.73"
+version = "0.1.74"
 description = "Shared utilities for Documente AI projects"
 authors = ["Tech <tech@llamitai.com>"]
 license = "MIT"