Encryptors 2.48__tar.gz → 2.49__tar.gz

{encryptors-2.48 → encryptors-2.49}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Encryptors
-Version: 2.48
+Version: 2.49
 Summary: End-to-end algorithm library
 Author: OSDental LLC
 Author-email: support@osdental.ai
@@ -16,7 +16,7 @@ Requires-Dist: ariadne==0.26.2
 Requires-Dist: azure-core==1.32.0
 Requires-Dist: azure-servicebus==7.13.0
 Requires-Dist: azure-storage-blob==12.24.0
-Requires-Dist: azure-identity==1.25.1
+Requires-Dist: azure-identity<2,>=1.24
 Requires-Dist: azure-keyvault-secrets==4.10.0
 Requires-Dist: certifi==2024.12.14
 Requires-Dist: cffi==1.17.1
@@ -32,7 +32,7 @@ Requires-Dist: isodate==0.7.2
 Requires-Dist: pycparser==2.22
 Requires-Dist: pydantic==2.12.2
 Requires-Dist: pydantic_core==2.41.4
-Requires-Dist: PyJWT==2.10.1
+Requires-Dist: PyJWT~=2.12.0
 Requires-Dist: aioodbc==0.5.0
 Requires-Dist: python-dotenv==1.0.1
 Requires-Dist: pydantic_settings==2.13.1
@@ -45,7 +45,8 @@ Requires-Dist: tenacity==9.1.2
 Requires-Dist: typing_extensions==4.15.0
 Requires-Dist: tzlocal==5.2
 Requires-Dist: urllib3==2.3.0
-Requires-Dist: redis==5.2.1
+Requires-Dist: redis<8,>=5
+Requires-Dist: redis-entraid==1.1.2
 Requires-Dist: colorlog==6.9.0
 Requires-Dist: click==8.2.0
 Requires-Dist: grpcio==1.75.0

{encryptors-2.48 → encryptors-2.49}/setup.py

@@ -1,8 +1,8 @@
 from setuptools import setup, find_packages
-# ANDERSON ESTO YA SE SUBIO Y ESTA ESTABLE, AUN TE QUEDA PENDIENTE LA AUDITORIA CON RSA Y AES DE ACCESSTOKEN
+# ANDERSON REVISAR EL CACHE LOCAL DEL KEYVAULT PARA VALIDAR SI FUNCIONA
 setup(
     name="Encryptors", 
-    version="2.48",
+    version="2.49",
     author="OSDental LLC",
     author_email="support@osdental.ai",
     description="End-to-end algorithm library",
@@ -24,7 +24,7 @@ setup(
         "azure-core==1.32.0",
         "azure-servicebus==7.13.0",
         "azure-storage-blob==12.24.0",
-        "azure-identity==1.25.1",
+        "azure-identity>=1.24,<2",
         "azure-keyvault-secrets==4.10.0",
         "certifi==2024.12.14",
         "cffi==1.17.1",
@@ -40,7 +40,7 @@ setup(
         "pycparser==2.22",
         "pydantic==2.12.2",
         "pydantic_core==2.41.4",
-        "PyJWT==2.10.1",
+        "PyJWT~=2.12.0",
         "aioodbc==0.5.0",
         "python-dotenv==1.0.1",
         "pydantic_settings==2.13.1",
@@ -53,7 +53,8 @@ setup(
         "typing_extensions==4.15.0",
         "tzlocal==5.2",
         "urllib3==2.3.0",
-        "redis==5.2.1",
+        "redis>=5,<8",
+        "redis-entraid==1.1.2",
         "colorlog==6.9.0",
         "click==8.2.0",
         "grpcio==1.75.0",

{encryptors-2.48 → encryptors-2.49}/src/Encryptors.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Encryptors
-Version: 2.48
+Version: 2.49
 Summary: End-to-end algorithm library
 Author: OSDental LLC
 Author-email: support@osdental.ai
@@ -16,7 +16,7 @@ Requires-Dist: ariadne==0.26.2
 Requires-Dist: azure-core==1.32.0
 Requires-Dist: azure-servicebus==7.13.0
 Requires-Dist: azure-storage-blob==12.24.0
-Requires-Dist: azure-identity==1.25.1
+Requires-Dist: azure-identity<2,>=1.24
 Requires-Dist: azure-keyvault-secrets==4.10.0
 Requires-Dist: certifi==2024.12.14
 Requires-Dist: cffi==1.17.1
@@ -32,7 +32,7 @@ Requires-Dist: isodate==0.7.2
 Requires-Dist: pycparser==2.22
 Requires-Dist: pydantic==2.12.2
 Requires-Dist: pydantic_core==2.41.4
-Requires-Dist: PyJWT==2.10.1
+Requires-Dist: PyJWT~=2.12.0
 Requires-Dist: aioodbc==0.5.0
 Requires-Dist: python-dotenv==1.0.1
 Requires-Dist: pydantic_settings==2.13.1
@@ -45,7 +45,8 @@ Requires-Dist: tenacity==9.1.2
 Requires-Dist: typing_extensions==4.15.0
 Requires-Dist: tzlocal==5.2
 Requires-Dist: urllib3==2.3.0
-Requires-Dist: redis==5.2.1
+Requires-Dist: redis<8,>=5
+Requires-Dist: redis-entraid==1.1.2
 Requires-Dist: colorlog==6.9.0
 Requires-Dist: click==8.2.0
 Requires-Dist: grpcio==1.75.0

{encryptors-2.48 → encryptors-2.49}/src/Encryptors.egg-info/SOURCES.txt

@@ -7,6 +7,8 @@ src/Encryptors.egg-info/entry_points.txt
 src/Encryptors.egg-info/requires.txt
 src/Encryptors.egg-info/top_level.txt
 src/Osdental/__init__.py
+src/Osdental/Cache/Redis.py
+src/Osdental/Cache/__init__.py
 src/Osdental/Cli/__init__.py
 src/Osdental/Database/BaseRepository.py
 src/Osdental/Database/Connection.py
@@ -37,8 +39,13 @@ src/Osdental/Graphql/_Helpers/_TenantPolicy.py
 src/Osdental/Graphql/_Helpers/_TokenService.py
 src/Osdental/Graphql/_Helpers/__init__.py
 src/Osdental/Helpers/AuditDispatcher.py
+src/Osdental/Helpers/AzureClassifier.py
+src/Osdental/Helpers/GrpcConnection.py
 src/Osdental/Helpers/KeyVaultService.py
+src/Osdental/Helpers/Resilience.py
 src/Osdental/Helpers/ResponseDecryptor.py
+src/Osdental/Helpers/WebsocketClient.py
+src/Osdental/Helpers/_Ports.py
 src/Osdental/Helpers/__init__.py
 src/Osdental/Http/APIClient.py
 src/Osdental/Http/_Helpers.py
@@ -49,12 +56,11 @@ src/Osdental/Messaging/RabbitMQ.py
 src/Osdental/Messaging/__init__.py
 src/Osdental/Models/ApiResponse.py
 src/Osdental/Models/AuditConfig.py
+src/Osdental/Models/Notification.py
 src/Osdental/Models/Response.py
 src/Osdental/Models/Token.py
 src/Osdental/Models/_Audit.py
 src/Osdental/Models/__init__.py
-src/Osdental/RedisCache/Redis.py
-src/Osdental/RedisCache/__init__.py
 src/Osdental/Rest/__init__.py
 src/Osdental/Rest/Context/RequestContext.py
 src/Osdental/Rest/Context/__init__.py

{encryptors-2.48 → encryptors-2.49}/src/Encryptors.egg-info/requires.txt

@@ -5,7 +5,7 @@ ariadne==0.26.2
 azure-core==1.32.0
 azure-servicebus==7.13.0
 azure-storage-blob==12.24.0
-azure-identity==1.25.1
+azure-identity<2,>=1.24
 azure-keyvault-secrets==4.10.0
 certifi==2024.12.14
 cffi==1.17.1
@@ -21,7 +21,7 @@ isodate==0.7.2
 pycparser==2.22
 pydantic==2.12.2
 pydantic_core==2.41.4
-PyJWT==2.10.1
+PyJWT~=2.12.0
 aioodbc==0.5.0
 python-dotenv==1.0.1
 pydantic_settings==2.13.1
@@ -34,7 +34,8 @@ tenacity==9.1.2
 typing_extensions==4.15.0
 tzlocal==5.2
 urllib3==2.3.0
-redis==5.2.1
+redis<8,>=5
+redis-entraid==1.1.2
 colorlog==6.9.0
 click==8.2.0
 grpcio==1.75.0

encryptors-2.49/src/Osdental/Cache/Redis.py

@@ -0,0 +1,267 @@
+import asyncio
+import json
+from typing import Dict, List, Optional, Any
+import redis.asyncio as redis
+from redis_entraid.cred_provider import (
+    create_from_default_azure_credential
+)
+from Osdental.Cache import ICacheService
+from Osdental.Exception.ControlledException import RedisException
+from Osdental.Helpers.Resilience import AzureResiliencePolicy, AzureTransientError
+from Osdental.Helpers.AzureClassifier import classify_redis
+from Osdental.Shared.Logger import logger
+from Osdental.Shared.Enums.Message import Message
+
+
+class RedisCacheAsync(ICacheService):
+
+    _instances: Dict[str, "RedisCacheAsync"] = {}
+    _lock = asyncio.Lock()
+
+    _policy = AzureResiliencePolicy(
+        "redis-cache",
+        max_attempts=3,
+        base_delay=0.5,
+        failure_threshold=5,
+    )
+
+    def __new__(cls, redis_host: str, redis_port: int = 6380):
+
+        key = f"{redis_host}:{redis_port}"
+
+        if key not in cls._instances:
+            cls._instances[key] = super().__new__(cls)
+
+        return cls._instances[key]
+
+    def __init__(
+        self,
+        redis_host: str,
+        redis_port: int = 6380
+    ):
+
+        if hasattr(self, "_initialized"):
+            return
+
+        self.redis_host = redis_host
+        self.redis_port = redis_port
+
+        self.client = None
+
+        self._initialized = True
+
+
+    async def _call(self, func, *args, **kwargs):
+        """
+        Ejecuta una operación de Redis a través de la policy.
+        Clasifica el error y deja que la policy decida si reintenta.
+        Si se agota o el circuito está abierto, convierte a RedisException.
+        """
+        await self._ensure_connection()
+
+        async def _inner():
+            try:
+                return await func(*args, **kwargs)
+            except Exception as exc:
+                raise classify_redis(exc)
+
+        try:
+            return await self._policy.execute(_inner)
+        except AzureTransientError as exc:
+            logger.error("redis.exhausted error=%s", exc)
+            raise RedisException(message=Message.UNEXPECTED_ERROR_MSG, error=str(exc))
+        except Exception as exc:
+            raise RedisException(message=Message.UNEXPECTED_ERROR_MSG, error=str(exc))
+        
+
+    async def connect(self):
+        if self.client:
+            return
+
+        async with self._lock:
+
+            if self.client:
+                return
+
+            try:
+                credential_provider = (
+                    create_from_default_azure_credential(
+                        ("https://redis.azure.com/.default",)
+                    )
+                )
+
+                self.client = redis.Redis(
+                    host=self.redis_host,
+                    port=self.redis_port,
+                    ssl=True,
+                    credential_provider=credential_provider,
+                    decode_responses=True,
+                    health_check_interval=30,
+                    retry_on_timeout=True,
+                    socket_connect_timeout=5,
+                    socket_timeout=5,
+                    max_connections=50,
+                    socket_keepalive=True
+                )
+
+                await self.client.ping()
+
+                logger.info(
+                    "Redis connected with Managed Identity"
+                )
+
+            except Exception as e:
+                self.client = None
+
+                logger.error(
+                    f"Redis connection error: {str(e)}"
+                )
+
+                raise RedisException(
+                    message=Message.UNEXPECTED_ERROR_MSG,
+                    error=str(e)
+                )
+
+    async def _ensure_connection(self):
+
+        if not self.client:
+            await self.connect()
+
+    async def set_dict(
+        self,
+        key: str,
+        value: Dict[str, Any],
+        ttl: Optional[int] = None
+    ):
+
+        await self._call(
+            self.client.set(
+                key,
+                json.dumps(value),
+                ex=ttl
+            )
+        )
+
+
+    async def set_str(
+        self,
+        key: str,
+        value: str,
+        ttl: Optional[int] = None
+    ):
+
+        await self._call(
+            self.client.set(
+                key,
+                value,
+                ex=ttl
+            )
+        )
+
+    async def get_dict(
+        self,
+        key: str
+    ) -> Optional[Dict[str, Any]]:
+
+        value = await self._call(
+            self.client.get(key)
+        )
+
+        return json.loads(value) if value else None
+
+
+    async def get_str(
+        self,
+        key: str
+    ) -> Optional[str]:
+
+        return await self._call(
+            self.client.get(key)
+        )
+
+
+    async def delete(self, key: str) -> bool:
+
+        result = await self._call(
+            self.client.delete(key)
+        )
+
+        return result > 0
+
+
+    async def exists(self, key: str) -> bool:
+
+        result = await self._call(
+            self.client.exists(key)
+        )
+
+        return result > 0
+
+
+    async def flush(self):
+
+        await self._call(
+            self.client.flushdb()
+        )
+
+
+    async def flush_all(self):
+
+        await self._call(
+            self.client.flushall()
+        )
+
+
+    async def mget(
+        self,
+        keys: List[str]
+    ) -> List[Optional[Any]]:
+
+        values = await self._call(
+            self.client.mget(keys)
+        )
+
+        return [
+            json.loads(value)
+            if value else None
+            for value in values
+        ]
+        
+
+    async def clear_cache(self, prefix: str):
+
+        await self._ensure_connection()
+
+        async for key in self._scan_keys(
+            match=f"{prefix}*"
+        ):
+
+            await self._call(self.client.delete(key))
+
+
+    async def _scan_keys(self, match: str = "*"):
+
+        async for key in self.client.scan_iter(
+            match=match
+        ):
+            yield key
+
+    async def close(self):
+
+        try:
+
+            if self.client:
+
+                await self.client.aclose()
+
+                self.client = None
+
+                logger.info(
+                    "Redis connection closed"
+                )
+
+        except Exception as e:
+
+            logger.error(
+                f"Redis close error: {str(e)}"
+            )

encryptors-2.49/src/Osdental/Cache/__init__.py

@@ -0,0 +1,53 @@
+from typing import Protocol, Optional, Dict, List, Any
+
+
+class ICacheService(Protocol):
+
+    async def set_dict(self, key: str, value: Dict[str, Any], ttl: Optional[int] = None):
+        """Set a JSON value in the cache."""
+        pass
+
+    async def set_str(self, key: str, value: str, ttl: Optional[int] = None):
+        """Set a string value in the cache."""
+        pass
+
+    async def get_dict(self, key: str) -> Optional[Dict[str, Any]]:
+        """Get a JSON value from the cache and convert it back to a Python object."""
+        pass
+
+
+    async def get_str(self, key: str) -> Optional[str]:
+        """Get a string value from the cache."""
+        pass
+
+    async def delete(self, key: str) -> bool:
+        """Delete a value from the cache."""
+        pass
+
+    async def exists(self, key: str) -> bool:
+        """Check if a key exists in the cache."""
+        pass
+
+    async def flush(self):
+        """Flush all keys in the cache."""
+        pass
+    
+    async def flush_all(self):
+        """Flush all keys in all Redis databases."""
+        pass
+
+    async def mget(self, keys:List[str]) -> List[Optional[str]]:
+        """Get multiple values from the cache."""
+        pass
+
+    async def clear_cache(self, prefix: str):
+        """Delete all keys matching the given prefix."""
+        pass
+
+    async def _scan_keys(self, match: str = "*"):
+        """Asynchronous generator to scan keys matching a pattern."""
+        pass
+
+    async def close(self):
+        """Close the connection pool and Redis client."""
+        pass

{encryptors-2.48 → encryptors-2.49}/src/Osdental/Cli/__init__.py

@@ -44,7 +44,7 @@ def serve(port: int):
 @click.argument('redis_env')
 async def clean_redis(redis_env: str):
     try:
-        from Osdental.RedisCache.Redis import RedisCacheAsync
+        from Osdental.Cache.Redis import RedisCacheAsync
         redis_url = os.getenv(redis_env)
         if not redis_url:
             logger.warning(f'Environment variable not found: {redis_env}')

encryptors-2.49/src/Osdental/Database/BaseRepository.py

@@ -0,0 +1,195 @@
+from collections.abc import Iterable
+from typing import Any
+from sqlalchemy import text
+from sqlalchemy.exc import ResourceClosedError, DBAPIError
+from sqlalchemy.ext.asyncio import AsyncSession
+from Osdental.Exception.ControlledException import DatabaseException
+from Osdental.Helpers.Resilience import AzureResiliencePolicy, AzureTransientError
+from Osdental.Shared.Utils.DataNormalizer import normalize
+from Osdental.Shared.Enums.Message import Message
+
+_TRANSIENT_SQL_ERRORS = {
+    "08S01", "40197", "40501", "40613", "49918",
+    "4060", "10928", "10929", "10053", "10054", "10060"
+}
+
+def _is_transient(exc: Exception) -> bool:
+    msg = str(exc).upper()
+    return any(code in msg for code in _TRANSIENT_SQL_ERRORS)
+
+class BaseRepository:
+    
+    _policy = AzureResiliencePolicy(
+        "sql-database",
+        max_attempts=3,
+        base_delay=1.0,
+        failure_threshold=5,
+    )
+
+    def __init__(self, async_session: AsyncSession):
+        self.async_session = async_session
+    
+
+    def _get_status_value(self, rows: dict, *possible_keys: str):
+        for key in possible_keys:
+            if key in rows:
+                return rows[key]
+        return None
+
+
+    async def _safe_execute(self, query: str, params: dict | None = None):
+        async def _inner():
+            try:
+                return await self.async_session.execute(text(query), params or {})
+            except DBAPIError as exc:
+                if _is_transient(exc):
+                    raise AzureTransientError(str(exc)) from exc
+                raise
+        return await self._policy.execute(_inner)
+
+
+    async def _execute_query(
+        self,
+        query: str,
+        params: dict | None = None,
+        *,
+        validate: bool = False,
+        success_codes: str | int | Iterable[str | int] | None = None,
+        many: bool = False,
+        as_dict: bool = False
+    ) -> Any:
+        
+        result = await self._safe_execute(query, params)
+        
+        row = (
+            result.mappings().all()
+            if many
+            else result.mappings().first()
+        )
+
+        if validate and row is not None:
+            validation_row = None
+
+            if many:
+
+                if (
+                    isinstance(row, list)
+                    and len(row) == 1
+                ):
+                    validation_row = row[0]
+
+            else:
+
+                validation_row = row
+
+            if validation_row is not None:
+
+                status_code = self._get_status_value(
+                    validation_row,
+                    "statusCode",
+                    "STATUS_CODE",
+                    "status_code"
+                )
+
+                status_message = self._get_status_value(
+                    validation_row,
+                    "statusMessage",
+                    "STATUS_MESSAGE",
+                    "status_message"
+                )
+
+                if status_code is not None and success_codes is not None:
+
+                    if not isinstance(success_codes, tuple):
+
+                        if isinstance(success_codes, Iterable) and not isinstance(success_codes, (str, bytes)):
+                            success_codes = tuple(success_codes)
+                        else:
+                            success_codes = (success_codes,)
+
+                    if status_code not in success_codes:
+                        raise DatabaseException(
+                            message=Message.UNEXPECTED_ERROR_MSG,
+                            error=status_message,
+                            status_code=status_code
+                        )
+
+        if as_dict and row is not None:
+            return normalize(row)
+
+        return row
+
+
+    async def _execute_command(
+        self,
+        query: str,
+        params: dict | None = None,
+        *,
+        validate: bool = True,
+        success_codes: str | int | Iterable[str | int] | None = None,
+        as_dict: bool = False,
+        commit_on_failure: bool = False
+    ) -> Any:
+        
+        result = await self._safe_execute(query, params)
+
+        try:
+            row = result.mappings().first()
+        except ResourceClosedError:
+            return None
+
+        if not validate or not row:
+            return normalize(row) if as_dict else row
+
+
+        status_code = self._get_status_value(
+            row,
+            "statusCode",
+            "STATUS_CODE",
+            "status_code"
+        )
+
+        status_message = self._get_status_value(
+            row,
+            "statusMessage",
+            "STATUS_MESSAGE",
+            "status_message"
+        )
+
+        # Si no se define success_codes, solo valida que no sea None
+        if success_codes is None:
+            if status_code is None:
+                raise DatabaseException(
+                    message="Status code missing",
+                    error="Status code missing",
+                    status_code="DB_ERROR_MISSING"
+                )
+
+        else:
+
+            if not isinstance(success_codes, tuple):
+                if isinstance(success_codes, Iterable) and not isinstance(success_codes, (str, bytes)):
+                    success_codes = tuple(success_codes)
+                else:
+                    success_codes = (success_codes,)
+
+            if status_code not in success_codes:
+                if commit_on_failure:
+                    await self.async_session.commit()
+                    
+                raise DatabaseException(
+                    message=status_message,
+                    error=status_message,
+                    status_code=status_code
+                )
+
+        return normalize(row) if as_dict else row
+    
+
+    async def _execute_scalar(
+        self,
+        query: str,
+        params: dict | None = None
+    ) -> Any | None:
+        result = await self._safe_execute(query, params)
+        return result.scalar_one_or_none()