Encryptors 2.78__tar.gz → 2.81.0__tar.gz

{encryptors-2.78 → encryptors-2.81.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Encryptors
-Version: 2.78
+Version: 2.81.0
 Summary: End-to-end algorithm library
 Author: OSDental LLC
 Author-email: support@osdental.ai
@@ -57,7 +57,6 @@ Requires-Dist: bcrypt==4.3.0
 Requires-Dist: azure-monitor-opentelemetry==1.8.1
 Requires-Dist: uvicorn==0.37.0
 Requires-Dist: gunicorn==23.0.0
-Requires-Dist: joserfc==1.5.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{encryptors-2.78 → encryptors-2.81.0}/setup.py

@@ -1,8 +1,8 @@
 from setuptools import setup, find_packages
-
+# ANDERSON REVISAR EL CACHE LOCAL DEL KEYVAULT PARA VALIDAR SI FUNCIONA
 setup(
     name="Encryptors", 
-    version="2.78",
+    version="2.81.0",
     author="OSDental LLC",
     author_email="support@osdental.ai",
     description="End-to-end algorithm library",
@@ -64,8 +64,7 @@ setup(
         "bcrypt==4.3.0",
         "azure-monitor-opentelemetry==1.8.1",
         "uvicorn==0.37.0",
-        "gunicorn==23.0.0",
-        "joserfc==1.5.0",
+        "gunicorn==23.0.0"
     ],
     entry_points={
     'console_scripts': [

{encryptors-2.78 → encryptors-2.81.0}/src/Encryptors.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Encryptors
-Version: 2.78
+Version: 2.81.0
 Summary: End-to-end algorithm library
 Author: OSDental LLC
 Author-email: support@osdental.ai
@@ -57,7 +57,6 @@ Requires-Dist: bcrypt==4.3.0
 Requires-Dist: azure-monitor-opentelemetry==1.8.1
 Requires-Dist: uvicorn==0.37.0
 Requires-Dist: gunicorn==23.0.0
-Requires-Dist: joserfc==1.5.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

encryptors-2.81.0/src/Encryptors.egg-info/SOURCES.txt

@@ -0,0 +1,96 @@
+README.md
+setup.py
+src/Encryptors.egg-info/PKG-INFO
+src/Encryptors.egg-info/SOURCES.txt
+src/Encryptors.egg-info/dependency_links.txt
+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
+src/Osdental/Database/SqlExceptionTranslator.py
+src/Osdental/Database/SqlTransientDetector.py
+src/Osdental/Database/StoredProcedureResultValidator.py
+src/Osdental/Database/__init__.py
+src/Osdental/Decorators/Grpc.py
+src/Osdental/Decorators/PublicResolver.py
+src/Osdental/Decorators/Retry.py
+src/Osdental/Decorators/SecureResolver.py
+src/Osdental/Decorators/SqlDataNormalizer.py
+src/Osdental/Decorators/__init__.py
+src/Osdental/Encryptor/Aes.py
+src/Osdental/Encryptor/Argon2.py
+src/Osdental/Encryptor/Bcrypt.py
+src/Osdental/Encryptor/Jwt.py
+src/Osdental/Encryptor/Rsa.py
+src/Osdental/Encryptor/Sha512.py
+src/Osdental/Encryptor/__init__.py
+src/Osdental/Exception/ControlledException.py
+src/Osdental/Exception/__init__.py
+src/Osdental/Graphql/__init__.py
+src/Osdental/Graphql/Extensions/AuditExtension.py
+src/Osdental/Graphql/Extensions/__init__.py
+src/Osdental/Graphql/Models/__init__.py
+src/Osdental/Graphql/_Exceptions/__init__.py
+src/Osdental/Graphql/_Helpers/_AuditHelper.py
+src/Osdental/Graphql/_Helpers/_ExtractAuthToken.py
+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
+src/Osdental/Http/__init__.py
+src/Osdental/Messaging/AzureServiceBus.py
+src/Osdental/Messaging/Kafka.py
+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/Rest/__init__.py
+src/Osdental/Rest/Context/RequestContext.py
+src/Osdental/Rest/Context/__init__.py
+src/Osdental/Rest/Middlewares/RequestContextMiddleware.py
+src/Osdental/Rest/Middlewares/__init__.py
+src/Osdental/Shared/Logger.py
+src/Osdental/Shared/__init__.py
+src/Osdental/Shared/Enums/Code.py
+src/Osdental/Shared/Enums/Constant.py
+src/Osdental/Shared/Enums/FileType.py
+src/Osdental/Shared/Enums/GrahpqlOperation.py
+src/Osdental/Shared/Enums/Message.py
+src/Osdental/Shared/Enums/Profile.py
+src/Osdental/Shared/Enums/__init__.py
+src/Osdental/Shared/Utils/CaseConverter.py
+src/Osdental/Shared/Utils/CodeGenerator.py
+src/Osdental/Shared/Utils/DataNormalizer.py
+src/Osdental/Shared/Utils/DataUtils.py
+src/Osdental/Shared/Utils/DateUtils.py
+src/Osdental/Shared/Utils/FileMetaData.py
+src/Osdental/Shared/Utils/HashValidator.py
+src/Osdental/Shared/Utils/Mapper.py
+src/Osdental/Shared/Utils/PasswordGenerator.py
+src/Osdental/Shared/Utils/QueryGenerator.py
+src/Osdental/Shared/Utils/RsaUtils.py
+src/Osdental/Shared/Utils/TextProcessor.py
+src/Osdental/Shared/Utils/__init__.py
+src/Osdental/Storage/AzureBlobStorage.py
+src/Osdental/Storage/S3Storage.py
+src/Osdental/Storage/__init__.py

{encryptors-2.78 → encryptors-2.81.0}/src/Encryptors.egg-info/requires.txt

@@ -46,4 +46,3 @@ bcrypt==4.3.0
 azure-monitor-opentelemetry==1.8.1
 uvicorn==0.37.0
 gunicorn==23.0.0
-joserfc==1.5.0

encryptors-2.81.0/src/Osdental/Cli/__init__.py

@@ -0,0 +1,118 @@
+import os
+import sys
+import subprocess
+import platform
+import click
+from Osdental.Shared.Logger import logger
+from Osdental.Shared.Enums.Message import Message
+
+
+@click.group()
+def cli():
+    """Custom commands to manage the project."""
+    pass
+
+@cli.command()
+def clean():
+    """Borrar todos los __pycache__."""
+    if platform.system() == 'Windows':
+        subprocess.run('for /d /r . %d in (__pycache__) do @if exist "%d" rd /s/q "%d"', shell=True)
+    else:
+        subprocess.run("find . -name '__pycache__' -type d -exec rm -rf {} +", shell=True)
+
+    logger.info(Message.PYCACHE_CLEANUP_SUCCESS_MSG)
+
+@cli.command()
+@click.argument('port')
+def start(port: int):
+    """Start the FastAPI server.."""
+    try:
+        subprocess.run(['uvicorn', 'app:app', '--port', str(port), '--reload'], check=True)
+    except subprocess.CalledProcessError as e:
+        logger.error(f'{Message.SERVER_NETWORK_ACCESS_ERROR_MSG}: {e}')
+
+@cli.command()
+@click.argument('port')
+def serve(port: int):
+    """Set up the FastAPI server accessible from any machine."""
+    try:
+        subprocess.run(['uvicorn', 'app:app', '--host', '0.0.0.0', '--port', str(port), '--reload'], check=True)
+    except subprocess.CalledProcessError as e:
+        logger.error(f'{Message.SERVER_NETWORK_ACCESS_ERROR_MSG}: {e}')
+
+@cli.command("clean-redis")
+@click.argument('redis_env')
+async def clean_redis(redis_env: str):
+    try:
+        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}')
+            return
+        
+        redis = RedisCacheAsync(redis_url=redis_url)
+        await redis.flush()
+        logger.info(Message.REDIS_CLEANUP_SUCCESS_MSG)
+    except Exception as e:
+        logger.error(f'{Message.REDIS_CLEANUP_ERROR_MSG}: {e}')
+
+@cli.command(name='proto-files')
+@click.argument('name')
+def proto_files(name: str):
+    proto_dir = os.path.join('src', 'Infrastructure', 'Grpc', 'Proto').replace('\\', '/')
+    gen_dir = os.path.join('src', 'Infrastructure', 'Grpc', 'Generated').replace('\\', '/')
+
+    proto_path = os.path.join(proto_dir, f'{name}.proto').replace('\\', '/')
+    common_path = os.path.join(proto_dir, 'Common.proto').replace('\\', '/')
+
+    common_py = os.path.join(gen_dir, 'Common_pb2.py').replace('\\', '/')
+    common_grpc_py = os.path.join(gen_dir, 'Common_pb2_grpc.py').replace('\\', '/')
+
+    proto_files = [proto_path]
+    if not (os.path.exists(common_py) and os.path.exists(common_grpc_py)):
+        proto_files.append(common_path)
+
+    cmd = [
+        sys.executable, "-m", "grpc_tools.protoc",
+        f"-I={proto_dir}",
+        f"--python_out={gen_dir}",
+        f"--grpc_python_out={gen_dir}",
+        *proto_files
+]
+
+    subprocess.run(cmd, shell=False, check=True)
+    logger.info(Message.PROTO_FILES_GENERATED_MSG)
+
+@cli.command('run-server')
+@click.option('--host', default="0.0.0.0", help='Host where to set up the server')
+@click.option('--port', default=5000, help='Server port')
+@click.option('--workers', default=4, help='Number of workers')
+def run_server(host, port, workers):
+    """
+        Launch the application with uvicorn on Windows or gunicorn on other systems
+        :host
+        :port
+        :workers
+    """
+    if sys.platform.startswith('win'):
+        cmd = [
+            sys.executable, '-m', 'uvicorn',
+            'app:app',
+            '--host', host,
+            '--port', str(port),
+            '--workers', str(workers)
+        ]
+    else:
+        cmd = [
+            sys.executable, '-m', 'gunicorn',
+            'app:app',
+            '-k', 'uvicorn.workers.UvicornWorker',
+            '--bind', f'{host}:{port}',
+            '--workers', str(workers)
+        ]
+    
+    logger.info(f'Running: {' '.join(cmd)}')
+    subprocess.run(cmd)
+    
+if __name__ == "__main__":
+    cli()

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

@@ -0,0 +1,171 @@
+from collections.abc import Iterable
+from typing import Any
+
+from sqlalchemy import text
+from sqlalchemy.exc import ResourceClosedError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from Osdental.Exception.ControlledException import DatabaseException
+from Osdental.Helpers.Resilience import (
+    AzureResiliencePolicy,
+    AzureTransientError,
+)
+from Osdental.Database.SqlExceptionTranslator import SqlExceptionTranslator
+from Osdental.Database.SqlTransientDetector import SqlTransientDetector
+from Osdental.Database.StoredProcedureResultValidator import (
+    StoredProcedureResultValidator,
+)
+from Osdental.Shared.Utils.DataNormalizer import normalize
+
+
+class BaseRepository:
+
+    _policy = AzureResiliencePolicy(
+        "sql-database",
+        max_attempts=3,
+        base_delay=1,
+        failure_threshold=5,
+    )
+
+    def __init__(
+        self,
+        async_session: AsyncSession,
+    ):
+        self.async_session = async_session
+
+    async def _safe_execute(
+        self,
+        query: str,
+        params: dict | None = None,
+    ):
+
+        async def execute():
+
+            try:
+
+                return await self.async_session.execute(
+                    text(query),
+                    params or {},
+                )
+
+            except Exception as exc:
+
+                if SqlTransientDetector.is_transient(exc):
+                    raise AzureTransientError(
+                        str(exc)
+                    ) from exc
+
+                raise
+
+        try:
+
+            return await self._policy.execute(
+                execute
+            )
+
+        except Exception as exc:
+
+            raise SqlExceptionTranslator.translate(
+                exc
+            ) from exc
+
+    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,
+        )
+
+        rows = (
+            result.mappings().all()
+            if many
+            else result.mappings().first()
+        )
+
+        if validate:
+
+            row = rows
+
+            if (
+                many
+                and isinstance(rows, list)
+                and len(rows) == 1
+            ):
+                row = rows[0]
+
+            StoredProcedureResultValidator.validate(
+                row,
+                success_codes,
+            )
+
+        if as_dict:
+            return normalize(rows)
+
+        return rows
+
+    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 validate:
+
+            try:
+
+                StoredProcedureResultValidator.validate(
+                    row,
+                    success_codes,
+                )
+
+            except DatabaseException:
+
+                if commit_on_failure:
+                    await self.async_session.commit()
+
+                raise
+
+        if as_dict:
+            return normalize(row)
+
+        return 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()

encryptors-2.81.0/src/Osdental/Database/SqlExceptionTranslator.py

@@ -0,0 +1,85 @@
+import logging
+
+from sqlalchemy.exc import (
+    DBAPIError,
+    IntegrityError,
+    OperationalError,
+    ProgrammingError,
+    DataError,
+)
+
+from Osdental.Exception.ControlledException import DatabaseException
+from Osdental.Shared.Enums.Message import Message
+
+logger = logging.getLogger(__name__)
+
+
+class SqlExceptionTranslator:
+
+    _ERRORS = {
+
+        IntegrityError: (
+            "It was not possible to save the information.",
+            "DB_ERROR_INTEGRITY",
+        ),
+
+        OperationalError: (
+            "The database is not available at this time.",
+            "DB_ERROR_UNAVAILABLE",
+        ),
+
+        ProgrammingError: (
+            "An error occurred in the SQL query.",
+            "DB_ERROR_PROGRAMMING",
+        ),
+
+        DataError: (
+            "The data sent to the database is invalid.",
+            "DB_ERROR_DATA",
+        ),
+
+        DBAPIError: (
+            Message.UNEXPECTED_ERROR_MSG,
+            "DB_ERROR",
+        ),
+    }
+
+    @classmethod
+    def translate(
+        cls,
+        exc: Exception,
+    ) -> DatabaseException:
+
+        logger.exception(exc)
+
+        detail = cls._get_detail(exc)
+
+        for exception_type, (message, status_code) in cls._ERRORS.items():
+
+            if isinstance(exc, exception_type):
+                logger.error(f"Database error: {message} - Detail: {detail}")
+                return DatabaseException(
+                    error=detail,
+                    status_code=status_code,
+                )
+
+        return DatabaseException(
+            message=Message.UNEXPECTED_ERROR_MSG,
+            error=detail,
+            status_code="UNEXPECTED_ERROR",
+        )
+
+    @staticmethod
+    def _get_detail(
+        exc: Exception,
+    ) -> str:
+
+        if isinstance(exc, DBAPIError):
+
+            original = getattr(exc, "orig", None)
+
+            if original is not None:
+
+                return str(original)
+
+        return str(exc)

encryptors-2.81.0/src/Osdental/Database/SqlTransientDetector.py

@@ -0,0 +1,44 @@
+from sqlalchemy.exc import DBAPIError
+
+_SQLSTATE_TRANSIENT_ERRORS = frozenset({
+    "08S01",   # Communication link failure
+    "40197",   # Azure SQL transient error
+    "40501",   # Service busy
+    "40613",   # Database unavailable
+    "49918",   # Not enough resources
+    "4060",    # Cannot open database
+    "10928",   # Resource limit
+    "10929",   # Resource limit
+    "10053",   # Connection aborted
+    "10054",   # Connection reset
+    "10060",   # Connection timeout
+})
+
+
+class SqlTransientDetector:
+    """
+    Detecta si un DBAPIError corresponde a un error transitorio
+    susceptible de reintento.
+    """
+
+    @staticmethod
+    def is_transient(exc: DBAPIError) -> bool:
+
+        original = getattr(exc, "orig", None)
+
+        if original is None:
+            return False
+
+        args = getattr(original, "args", ())
+
+        for arg in args:
+
+            if not isinstance(arg, str):
+                continue
+
+            upper = arg.upper()
+
+            if any(code in upper for code in _SQLSTATE_TRANSIENT_ERRORS):
+                return True
+
+        return False

encryptors-2.81.0/src/Osdental/Database/StoredProcedureResultValidator.py

@@ -0,0 +1,91 @@
+from collections.abc import Iterable
+from typing import Any
+
+from Osdental.Exception.ControlledException import DatabaseException
+from Osdental.Shared.Enums.Message import Message
+
+
+class StoredProcedureResultValidator:
+
+    STATUS_CODE_KEYS = (
+        "statusCode",
+        "STATUS_CODE",
+        "status_code",
+    )
+
+    STATUS_MESSAGE_KEYS = (
+        "statusMessage",
+        "STATUS_MESSAGE",
+        "status_message",
+    )
+
+    @classmethod
+    def validate(
+        cls,
+        row: dict[str, Any] | None,
+        success_codes: str | int | Iterable[str | int] | None,
+    ) -> None:
+
+        if row is None:
+            return
+
+        status_code = cls._get_value(
+            row,
+            cls.STATUS_CODE_KEYS,
+        )
+
+        status_message = cls._get_value(
+            row,
+            cls.STATUS_MESSAGE_KEYS,
+        )
+
+        if success_codes is None:
+
+            if status_code is None:
+
+                raise DatabaseException(
+                    message="Status code missing.",
+                    error="Stored Procedure did not return a status code.",
+                    status_code="DB_STATUS_CODE_MISSING",
+                )
+
+            return
+
+        success_codes = cls._normalize(success_codes)
+
+        if status_code not in success_codes:
+
+            raise DatabaseException(
+                message=status_message or Message.UNEXPECTED_ERROR_MSG,
+                error=status_message or Message.UNEXPECTED_ERROR_MSG,
+                status_code=status_code,
+            )
+
+    @staticmethod
+    def _normalize(
+        success_codes: str | int | Iterable[str | int],
+    ) -> tuple[str | int, ...]:
+
+        if isinstance(success_codes, tuple):
+            return success_codes
+
+        if isinstance(success_codes, Iterable) and not isinstance(
+            success_codes,
+            (str, bytes),
+        ):
+            return tuple(success_codes)
+
+        return (success_codes,)
+
+    @staticmethod
+    def _get_value(
+        row: dict[str, Any],
+        keys: tuple[str, ...],
+    ) -> Any | None:
+
+        for key in keys:
+
+            if key in row:
+                return row[key]
+
+        return None

{encryptors-2.78 → encryptors-2.81.0}/src/Osdental/Decorators/Grpc.py

@@ -1,8 +1,6 @@
-import logging
 import json
 from functools import wraps
-
-logger = logging.getLogger(__name__)
+from Osdental.Shared.Logger import logger
 
 def parse_rpc_request_payload(func):
 

encryptors-2.81.0/src/Osdental/Decorators/PublicResolver.py

@@ -0,0 +1,3 @@
+def public_resolver(resolver):
+    setattr(resolver, "_is_public", True)
+    return resolver

{encryptors-2.78 → encryptors-2.81.0}/src/Osdental/Decorators/Retry.py

@@ -1,8 +1,5 @@
 from functools import wraps
-from tenacity import (
-    retry, stop_after_attempt, 
-    wait_exponential, retry_if_exception_type
-)
+from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
 import grpc
 import httpx