documente_shared 0.1.72b0__tar.gz → 0.1.74__tar.gz

{documente_shared-0.1.72b0 → documente_shared-0.1.74}/PKG-INFO

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

{documente_shared-0.1.72b0 → documente_shared-0.1.74}/README.md

@@ -1,17 +1,17 @@
-
-# Documente Shared
-
-Utilidades para proyectos Documente AI
-
-## Instalación
-
-```bash
-make build
-```
-
-## Publicación
-Publica `documente-shared` en PyPi
-
-```bash
-make publish
+
+# Documente Shared
+
+Utilidades para proyectos Documente AI
+
+## Instalación
+
+```bash
+make build
+```
+
+## Publicación
+Publica `documente-shared` en PyPi
+
+```bash
+make publish
 ```

{documente_shared-0.1.72b0 → documente_shared-0.1.74}/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.72b0 → documente_shared-0.1.74}/documente_shared/application/exceptions.py

@@ -1,23 +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
+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.72b0 → documente_shared-0.1.74}/documente_shared/application/files.py

@@ -1,22 +1,22 @@
-from os import path
-from typing import Tuple, Optional
-
-
-def split_file_params(filepath: str) -> Tuple[str, str, str]:
-    folder_path = path.dirname(filepath)
-    filename = path.splitext(path.basename(filepath))[0]
-    extension = path.splitext(filepath)[1]
-    extension = extension.replace('.', '')
-    return folder_path, filename, extension
-
-
-def get_filename_from_path(file_path: Optional[str]) -> Optional[str]:
-    if not file_path:
-        return None
-    return path.basename(file_path)
-
-
-def remove_slash_from_path(file_path: str) -> str:
-    if file_path and file_path.startswith('/'):
-        return file_path[1:]
-    return file_path
+from os import path
+from typing import Tuple, Optional
+
+
+def split_file_params(filepath: str) -> Tuple[str, str, str]:
+    folder_path = path.dirname(filepath)
+    filename = path.splitext(path.basename(filepath))[0]
+    extension = path.splitext(filepath)[1]
+    extension = extension.replace('.', '')
+    return folder_path, filename, extension
+
+
+def get_filename_from_path(file_path: Optional[str]) -> Optional[str]:
+    if not file_path:
+        return None
+    return path.basename(file_path)
+
+
+def remove_slash_from_path(file_path: str) -> str:
+    if file_path and file_path.startswith('/'):
+        return file_path[1:]
+    return file_path

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.72b0 → documente_shared-0.1.74}/documente_shared/application/time_utils.py

@@ -1,13 +1,13 @@
-from datetime import datetime
-from typing import Union, Optional
-
-
-def get_datetime_from_data(input_datetime: Union[datetime, str]) -> Optional[datetime]:
-    if isinstance(input_datetime, datetime):
-        return input_datetime
-    elif isinstance(input_datetime, str) and bool(input_datetime):
-        try:
-            return datetime.fromisoformat(input_datetime)
-        except ValueError:
-            return None
-    return None
+from datetime import datetime
+from typing import Union, Optional
+
+
+def get_datetime_from_data(input_datetime: Union[datetime, str]) -> Optional[datetime]:
+    if isinstance(input_datetime, datetime):
+        return input_datetime
+    elif isinstance(input_datetime, str) and bool(input_datetime):
+        try:
+            return datetime.fromisoformat(input_datetime)
+        except ValueError:
+            return None
+    return None

{documente_shared-0.1.72b0 → documente_shared-0.1.74}/documente_shared/application/timezone.py

@@ -1,7 +1,7 @@
-from datetime import datetime, timezone
-
-
-def ensure_timezone(dt: datetime, tz=timezone.utc) -> datetime:
-    if dt.tzinfo is None:
-        return dt.replace(tzinfo=tz)
-    return dt
+from datetime import datetime, timezone
+
+
+def ensure_timezone(dt: datetime, tz=timezone.utc) -> datetime:
+    if dt.tzinfo is None:
+        return dt.replace(tzinfo=tz)
+    return dt

{documente_shared-0.1.72b0 → documente_shared-0.1.74}/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.74/documente_shared/domain/constants.py

@@ -0,0 +1,8 @@
+import pytz
+from os import environ
+
+
+la_paz_tz = pytz.timezone("America/La_Paz")
+
+DOCUMENTE_API_URL = environ.get("DOCUMENTE_API_URL")
+DOCUMENTE_API_KEY = environ.get("DOCUMENTE_API_KEY")