documente_shared 0.1.145__py3-none-any.whl

documente_shared/application/dates.py

@@ -0,0 +1,7 @@
+import pytz
+from datetime import datetime
+
+
+
+def utc_now() -> datetime:
+    return datetime.now(tz=pytz.utc)

documente_shared/application/digest.py

@@ -0,0 +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()

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/application/files.py

@@ -0,0 +1,27 @@
+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
+
+def remove_extension(filename: str) -> str:
+    if filename and '.' in filename:
+        return filename.rsplit('.', 1)[0]
+    return filename

documente_shared/application/json.py

@@ -0,0 +1,45 @@
+import re
+from typing import Any
+
+import unicodedata
+from unidecode import unidecode
+
+
+def underscoreize(data: Any) -> Any:
+    if isinstance(data, dict):
+        new_dict = {}
+        for key, value in data.items():
+            new_key = re.sub(r"(?<!^)(?=[A-Z])", "_", key).lower()
+            new_dict[new_key] = underscoreize(value)
+        return new_dict
+    elif isinstance(data, list):
+        return [underscoreize(item) for item in data]
+    else:
+        return data
+
+
+def safe_format(data: Any) -> Any:
+    if isinstance(data, dict):
+        new_dict = {}
+        for key, value in data.items():
+            new_key = unidecode(key.replace(" ", "_"))
+            new_dict[new_key] = safe_format(value)
+        return new_dict
+    elif isinstance(data, list):
+        return [safe_format(item) for item in data]
+    else:
+        return data
+
+
+def normalize_key(key: str) -> str:
+    normalized = unicodedata.normalize('NFC', key)
+    underscored = re.sub(r'\s+', '_', normalized)
+    return underscored
+
+
+def normalize_dict_keys(data: dict) -> dict:
+    return {normalize_key(k): v for k, v in data.items()}
+
+
+def normalize_list_keys(data: list) -> list:
+    return [normalize_dict_keys(item) for item in data]

documente_shared/application/numbers.py

@@ -0,0 +1,7 @@
+from decimal import Decimal
+
+
+def normalize_number(number: str | float | Decimal) -> str:
+    if not isinstance(number, Decimal):
+        number = Decimal(number)
+    return str(number.quantize(Decimal('0.001')))

documente_shared/application/payloads.py

@@ -0,0 +1,29 @@
+import re
+
+
+def camel_to_snake_key(name: str) -> str:
+    s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', name)
+    return re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1).lower()
+
+def camel_to_snake(data: dict | list) -> dict | list:
+    if isinstance(data, dict):
+        return {camel_to_snake_key(k): camel_to_snake(v) for k, v in data.items()}
+    elif isinstance(data, list):
+        return [camel_to_snake(item) for item in data]
+    else:
+        return data
+
+
+def snake_to_camel(data: dict | list) -> dict | list:
+    if isinstance(data, dict):
+        result = {}
+        for key, value in data.items():
+            parts = key.split("_")
+            camel_key = parts[0] + "".join(word.capitalize() for word in parts[1:])
+            result[camel_key] = snake_to_camel(value)
+        return result
+    elif isinstance(data, list):
+        return [snake_to_camel(item) for item in data]
+    else:
+        return data
+        

documente_shared/application/query_params.py

@@ -0,0 +1,133 @@
+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:]
+
+
+def parse_bool_to_str(input_value: bool) -> str:
+    return str(input_value).lower()
+
+
+@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/application/retry_utils.py

@@ -0,0 +1,69 @@
+import time
+import random
+from functools import wraps
+from typing import Optional, Callable
+from loguru import logger
+
+
+def retry_on_size_integrity(base_delay: float = 0.8, max_retries: int = 3):
+    def decorator(func: Callable):
+        @wraps(func)
+        def wrapper(self, file_key: str, *args, **kwargs) -> Optional[dict]:
+            for attempt in range(max_retries):
+                try:
+                    file_context = func(self, file_key, *args, **kwargs)
+
+                    if not file_context:
+                        logger.warning(
+                            f"[Intento {attempt+1}/{max_retries}] file_context es None para {file_key}"
+                        )
+                        if attempt < max_retries - 1:
+                            delay = base_delay * (2 ** attempt) + random.uniform(0, base_delay)
+                            time.sleep(delay)
+                            continue
+                        raise RuntimeError(f"No se pudo obtener file_context para {file_key}")
+
+                    if 'Body' not in file_context:
+                        logger.warning(
+                            f"[Intento {attempt+1}/{max_retries}] 'Body' no encontrado en file_context para {file_key}"
+                        )
+                        if attempt < max_retries - 1:
+                            delay = base_delay * (2 ** attempt) + random.uniform(0, base_delay)
+                            time.sleep(delay)
+                            continue
+                        raise RuntimeError(f"'Body' no encontrado en file_context para {file_key}")
+
+                    expected_size = file_context.get('ContentLength', 0)
+                    body = file_context['Body'].read()
+                    actual_size = len(body)
+
+                    if expected_size == actual_size:
+                        file_context['Body'] = body
+                        if attempt > 0:
+                            logger.info(f"Descarga exitosa de {file_key} después de {attempt+1} intentos")
+                        return file_context
+
+                    logger.warning(
+                        f"[Intento {attempt+1}/{max_retries}] Discrepancia de tamaño para {file_key}: "
+                        f"esperado={expected_size}, recibido={actual_size}"
+                    )
+
+                    if attempt < max_retries - 1:
+                        delay = base_delay * (2 ** attempt) + random.uniform(0, base_delay)
+                        time.sleep(delay)
+
+                except Exception as e:
+                    logger.error(
+                        f"[Intento {attempt+1}/{max_retries}] Error al descargar {file_key}: {type(e).__name__}: {str(e)}"
+                    )
+                    if attempt < max_retries - 1:
+                        delay = base_delay * (2 ** attempt) + random.uniform(0, base_delay)
+                        time.sleep(delay)
+                        continue
+                    raise
+
+            raise RuntimeError(
+                f"Descarga incompleta/inconsistente de S3 para {file_key} después de {max_retries} intentos"
+            )
+        return wrapper
+    return decorator

documente_shared/application/time_utils.py

@@ -0,0 +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

documente_shared/application/timezone.py

@@ -0,0 +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

documente_shared/domain/base_enum.py

@@ -0,0 +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
+        return None

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")