Encryptors 2.53__tar.gz → 2.54__tar.gz

{encryptors-2.53 → encryptors-2.54}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Encryptors
-Version: 2.53
+Version: 2.54
 Summary: End-to-end algorithm library
 Author: OSDental LLC
 Author-email: support@osdental.ai

{encryptors-2.53 → encryptors-2.54}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 # ANDERSON REVISAR EL CACHE LOCAL DEL KEYVAULT PARA VALIDAR SI FUNCIONA
 setup(
     name="Encryptors", 
-    version="2.53",
+    version="2.54",
     author="OSDental LLC",
     author_email="support@osdental.ai",
     description="End-to-end algorithm library",

{encryptors-2.53 → encryptors-2.54}/src/Encryptors.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Encryptors
-Version: 2.53
+Version: 2.54
 Summary: End-to-end algorithm library
 Author: OSDental LLC
 Author-email: support@osdental.ai

{encryptors-2.53 → encryptors-2.54}/src/Osdental/Cache/Redis.py

@@ -7,10 +7,9 @@ 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.Constants.Message import Message
+
 
 
 logger = logging.getLogger(__name__)
@@ -59,7 +58,6 @@ class RedisCacheAsync(ICacheService):
         """
         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()
 
@@ -86,12 +84,6 @@ class RedisCacheAsync(ICacheService):
                 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):
@@ -137,10 +129,7 @@ class RedisCacheAsync(ICacheService):
                     f"Redis connection error: {str(e)}"
                 )
 
-                raise RedisException(
-                    message=Message.UNEXPECTED_ERROR_MSG,
-                    error=str(e)
-                )
+                raise e
 
     async def _ensure_connection(self):
 

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

@@ -0,0 +1,137 @@
+import logging
+import os
+import sys
+import subprocess
+import platform
+import click
+
+
+logger = logging.getLogger(__name__)
+
+SERVER = "uvicorn"
+SERVER_PROD = "gunicorn"
+FILE_RUN_SERVER = "app:app"
+PYCACHE_CLEANUP_SUCCESS_MSG = "All __pycache__ have been removed."
+SERVER_NETWORK_ACCESS_ERROR_MSG = "Error making the server accessible on the network."
+REDIS_CLEANUP_SUCCESS_MSG = "Redis cleanup completed successfully."
+REDIS_CLEANUP_ERROR_MSG = "An error occurred while attempting to clean up Redis."
+PROTO_FILES_GENERATED_MSG = "The {name} Proto files have been successfully generated."
+
+@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(PYCACHE_CLEANUP_SUCCESS_MSG)
+
+@cli.command()
+@click.argument("port")
+def start(port: int):
+    """Start the FastAPI server.."""
+    try:
+        subprocess.run([SERVER, FILE_RUN_SERVER, "--port", str(port), "--reload"], check=True)
+    except subprocess.CalledProcessError as e:
+        logger.exception(f"{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([SERVER, FILE_RUN_SERVER, '--host', "0.0.0.0", "--port", str(port), "--reload"], check=True)
+    except subprocess.CalledProcessError as e:
+        logger.exception(f"{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(REDIS_CLEANUP_SUCCESS_MSG)
+    except Exception as e:
+        logger.exception(f"{REDIS_CLEANUP_ERROR_MSG}: {e}")
+
+@cli.command(name='proto-files')
+@click.argument('name')
+def proto_files(name: str):
+    
+    from pathlib import Path
+
+    GRPC_BASE_DIR = Path("src") / "Infrastructure" / "Grpc"
+    proto_dir = (GRPC_BASE_DIR / "Proto").as_posix()
+    gen_dir = (GRPC_BASE_DIR / "Generated").as_posix()
+
+    # 2. Rutas de los archivos .proto (reutilizando las variables posix anteriores)
+    proto_path = f"{proto_dir}/{name}.proto"
+    common_path = f"{proto_dir}/Common.proto"
+
+    # 3. Rutas para verificar si ya existen los archivos generados de Common
+    common_py = f"{gen_dir}/Common_pb2.py"
+    common_grpc_py = f"{gen_dir}/Common_pb2_grpc.py"
+
+    # 4. Lógica de compilación condicional
+    proto_files_to_compile = [proto_path]
+    # Nota: os.path.exists entiende perfectamente las rutas con '/' en Windows
+    if not (os.path.exists(common_py) and os.path.exists(common_grpc_py)):
+        proto_files_to_compile.append(common_path)
+
+    # 5. Comando para ejecutar protoc
+    cmd = [
+        sys.executable, "-m", "grpc_tools.protoc",
+        f"-I={proto_dir}",
+        f"--python_out={gen_dir}",
+        f"--grpc_python_out={gen_dir}",
+        *proto_files_to_compile
+    ]
+
+    subprocess.run(cmd, shell=False, check=True)
+    logger.info(PROTO_FILES_GENERATED_MSG.format(name=name))
+
+@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", SERVER,
+            FILE_RUN_SERVER,
+            "--host", host,
+            "--port", str(port),
+            "--workers", str(workers)
+        ]
+    else:
+        cmd = [
+            sys.executable, "-m", SERVER_PROD,
+            FILE_RUN_SERVER,
+            "-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.53 → encryptors-2.54}/src/Osdental/Constants/Message.py

@@ -7,9 +7,9 @@ class Message:
     PROCESS_SUCCESS_MSG = "Process executed successfully."
     NO_RESULTS_FOUND_MSG = "No records were found matching your request."
     INVALID_REQUEST_PARAMS_MSG = "Please review the required fields and try again."
-    SERVER_NETWORK_ACCESS_ERROR_MSG = "Error making the server accessible on the network."
+    
     HEXAGONAL_SERVICE_CREATED_MSG = "The hexagonal service structure was created."
-    PYCACHE_CLEANUP_SUCCESS_MSG = "All __pycache__ have been removed."
+    
     NO_PASSWORD_CHARACTERS_MSG = "There are no characters available to generate the password."
     INSUFFICIENT_LENGTH_MSG = "Insufficient length to meet minimum rules."
     LEGACY_NAME_REQUIRED_MSG = "Legacy name cannot be empty."
@@ -29,12 +29,11 @@ class Message:
     INVALID_FORMAT_MSG = "The provided data format is invalid."
     INVALID_AES_JSON_FORMAT_MSG = "Invalid JSON format in AES decrypted data."
     UNEXPECTED_DECRYPTED_DATA_FORMAT_MSG = "Unexpected format in decrypted data."
-    REDIS_CLEANUP_SUCCESS_MSG = "Redis cleanup completed successfully."
-    REDIS_CLEANUP_ERROR_MSG = "An error occurred while attempting to clean up Redis."
+    
+    
     DATABASE_EXECUTION_ERROR_MSG = "An unexpected error occurred while executing a database operation."
     DATABASE_INTEGRITY_ERROR_MSG = "A database integrity constraint was violated during execution."
     QUERY_NOT_PROVIDED_MSG = "Query not provided. Please include a valid query in your request."
     FILE_PATH_NOT_PROVIDED_MSG = "File path not provided."
-    PROTO_FILES_GENERATED_MSG = "Proto files have been successfully generated."
-    ERROR_INVALID_DATA_TYPE = "Invalid data type: expected dict, str, or list."
+    
     EXTERNAL_API_ERROR_MESSAGE = "An error occurred while consuming an external API."

{encryptors-2.53 → encryptors-2.54}/src/Osdental/Database/BaseRepository.py

@@ -5,8 +5,9 @@ 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.Constants.Message import Message
+from Osdental.Utils.DataNormalizer import normalize
+from Osdental.Enums.StatusCode import StatusCode
+
 
 _TRANSIENT_SQL_ERRORS = {
     "08S01", "40197", "40501", "40613", "49918",
@@ -109,9 +110,8 @@ class BaseRepository:
 
                     if status_code not in success_codes:
                         raise DatabaseException(
-                            message=Message.UNEXPECTED_ERROR_MSG,
-                            error=status_message,
-                            status_code=status_code
+                            message=status_message,
+                            error=status_message
                         )
 
         if as_dict and row is not None:
@@ -127,8 +127,7 @@ class BaseRepository:
         *,
         validate: bool = True,
         success_codes: str | int | Iterable[str | int] | None = None,
-        as_dict: bool = False,
-        commit_on_failure: bool = False
+        as_dict: bool = False
     ) -> Any:
         
         result = await self._safe_execute(query, params)
@@ -162,7 +161,7 @@ class BaseRepository:
                 raise DatabaseException(
                     message="Status code missing",
                     error="Status code missing",
-                    status_code="DB_ERROR_MISSING"
+                    status_code=StatusCode.INTERNAL_SERVER_ERROR
                 )
 
         else:
@@ -174,13 +173,11 @@ class BaseRepository:
                     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
+                    status_code=StatusCode.BUSINESS_RULE_WARNING
                 )
 
         return normalize(row) if as_dict else row

{encryptors-2.53 → encryptors-2.54}/src/Osdental/Decorators/Retry.py

@@ -1,5 +1,8 @@
 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
 

{encryptors-2.53 → encryptors-2.54}/src/Osdental/Decorators/SecureResolver.py

@@ -3,16 +3,17 @@ from functools import wraps
 from typing import Callable
 from graphql import GraphQLResolveInfo
 from Osdental.Models.Response import Response
-from Osdental.Shared.Enums.Profile import Profile
+from Osdental.Graphql.Models import BaseGraphQLContext
+from Osdental.Models.TokenClaims import UserTokenClaims
+from Osdental.Models.Token import AuthToken
+from Osdental.Enums.Profile import Profile
 from Osdental.Exception.ControlledException import (
     OSDException, AccessDeniedException
 )
-from Osdental.Graphql.Models import BaseGraphQLContext
-from Osdental.Helpers._Ports import IAuthTokenService
+from Osdental.Services import IAuthTokenService
 from Osdental.Helpers._AuthTokenProcessor import (
     extract_bearer_token, build_auth_token, decrypt_and_parse_payload
 )
-from Osdental.Models.TokenClaims import UserTokenClaims
 from Osdental.Enums.StatusCode import StatusCode
 
 
@@ -40,6 +41,7 @@ def resolver(public: bool = False, action=None):
             try:
                 context: BaseGraphQLContext = info.context
                 request = context.request
+                token: type[AuthToken] | None = None
 
                 # ── 1. AUTENTICACIÓN ──────────────────────────────
                 if not public:
@@ -106,7 +108,7 @@ def resolver(public: bool = False, action=None):
                 }
 
                 if isinstance(result, Response):
-                    decrypted_key = result.key or claims.aes_key_auth
+                    decrypted_key = result.key if not token else token.aes_key_auth
 
                 __test(
                     dispatcher=dispatcher,

encryptors-2.54/src/Osdental/Encryptor/Aes.py

@@ -0,0 +1,83 @@
+import logging
+import os
+import json
+import base64
+from typing import Dict, List
+from cryptography.hazmat.primitives.ciphers import (
+    Cipher, algorithms, modes
+)
+from Osdental.Constants.Constant import Constant
+
+logger = logging.getLogger(__name__)
+
+class AES:
+
+    IV_LENGTH = 32
+    TAG_LENGTH = 16
+
+    @staticmethod
+    def generate_key() -> str:
+        """Generates a random 256-bit AES key and returns it Base64 encoded."""
+        key = os.urandom(32)
+        return base64.b64encode(key).decode(Constant.DEFAULT_ENCODING)
+    
+    @classmethod
+    def encrypt(cls, aes_key:str, data:Dict[str,str] | str | List[Dict[str,str]]) -> str:
+        """
+        Encrypts data using AES-GCM.
+        Supports dictionary, string, or list inputs.
+
+        :param aes_key: AES key in Base64 format.
+        :param data: Data to be encrypted (dict, str, or list).
+        :return: Data encrypted in Base64.
+        """
+        if not isinstance(data, (dict, str, list)):
+            raise ValueError("Invalid data type: expected dict, str, or list.")
+
+        key = base64.b64decode(aes_key)
+        iv = os.urandom(cls.IV_LENGTH)
+        if isinstance(data, (dict, list)):
+            json_data = json.dumps(data)
+        else:
+            json_data = data
+
+        cipher = Cipher(algorithms.AES(key), modes.GCM(iv))
+        encryptor = cipher.encryptor()
+        ciphertext = encryptor.update(json_data.encode(Constant.DEFAULT_ENCODING)) + encryptor.finalize()
+        tag = encryptor.tag
+        encrypted_data = iv + ciphertext + tag
+
+        return base64.b64encode(encrypted_data).decode(Constant.DEFAULT_ENCODING)
+
+ 
+    @classmethod
+    def decrypt(cls, aes_key:str, encrypted_data:str, silent:bool = False):
+        """
+        Decrypts data using AES-GCM.
+        Expects encrypted data to represent either a JSON object (dict) or a plain string.
+
+        :param aes_key: AES key in Base64 format.
+        :param encrypted_data: Data encrypted in Base64.
+        :return: Decrypted data (either dict or str).
+        """
+
+        key = base64.b64decode(aes_key)
+        encrypted_data = base64.b64decode(encrypted_data)
+        iv = encrypted_data[:cls.IV_LENGTH]
+        tag = encrypted_data[-cls.TAG_LENGTH:]
+        ciphertext = encrypted_data[cls.IV_LENGTH:-cls.TAG_LENGTH]
+        cipher = Cipher(algorithms.AES(key), modes.GCM(iv, tag))
+        decryptor = cipher.decryptor()
+        plaintext = decryptor.update(ciphertext) + decryptor.finalize()
+
+        try:
+            decrypted_data = json.loads(plaintext.decode(Constant.DEFAULT_ENCODING))
+            return decrypted_data
+        except json.JSONDecodeError:
+            return plaintext.decode(Constant.DEFAULT_ENCODING)
+
+        # except Exception as e:
+        #     if not silent:
+        #         logger.exception(f'Unexpected AES decryption error: {str(e)}')
+                
+        #     raise AESEncryptException(error=str(e))

{encryptors-2.53 → encryptors-2.54}/src/Osdental/Encryptor/Bcrypt.py

@@ -1,6 +1,6 @@
 import bcrypt
 from Osdental.Exception.ControlledException import OSDException
-from Osdental.Shared.Enums.Constant import Constant
+from Osdental.Constants.Constant import Constant
 
 class BcryptPasswordManager:
     def __init__(self, rounds: int = 12):

encryptors-2.54/src/Osdental/Encryptor/Jwt.py

@@ -0,0 +1,35 @@
+import logging
+import jwt
+from typing import Dict, Any
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.backends import default_backend
+
+
+logger = logging.getLogger(__name__)
+
+class JWT:
+
+    @staticmethod
+    def generate_token(
+        payload: Dict[str, Any],
+        jwt_secret_key: str,
+        algorithm="HS256"
+    ) -> str:
+        
+        return jwt.encode(payload, jwt_secret_key, algorithm=algorithm)
+
+
+    @staticmethod
+    def extract_payload(
+        jwt_token: str,
+        jwt_secret_key: str
+    ) -> Dict[str, Any]:
+            
+        return jwt.decode(jwt_token, jwt_secret_key, algorithms=["HS256"])
+
+    @staticmethod
+    def generate_private_key(private_rsa: str):
+        
+        return serialization.load_pem_private_key(
+            private_rsa.encode(), password=None, backend=default_backend()
+        )

encryptors-2.54/src/Osdental/Encryptor/Rsa.py

@@ -0,0 +1,54 @@
+import logging
+import json
+from base64 import b64decode, b64encode
+from typing import Dict, Any
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import padding
+from cryptography.hazmat.primitives import hashes
+from Osdental.Constants.Constant import Constant
+
+
+logger = logging.getLogger(__name__)
+class RSAEncryptor:
+
+    @staticmethod
+    def encrypt(data: str | Dict[str, Any], public_key_rsa: str) -> str:
+        
+        if isinstance(data, dict):
+            data = json.dumps(data)
+
+        public_key = serialization.load_pem_public_key(public_key_rsa.encode(Constant.DEFAULT_ENCODING))
+        data_bytes = data.encode(Constant.DEFAULT_ENCODING)
+        encrypted_bytes = public_key.encrypt(
+            data_bytes,
+            padding.OAEP(
+                mgf=padding.MGF1(algorithm=hashes.SHA256()),
+                algorithm=hashes.SHA256(),
+                label=None
+            )
+        )
+
+        return b64encode(encrypted_bytes).decode(Constant.DEFAULT_ENCODING)
+
+
+    @staticmethod
+    def decrypt(data: str, private_key_rsa: str) -> str:
+        
+        encrypted_bytes = b64decode(data)
+        private_key = serialization.load_pem_private_key(private_key_rsa.encode(Constant.DEFAULT_ENCODING), password=None)
+        decrypted_bytes = private_key.decrypt(
+            encrypted_bytes,
+            padding.OAEP(
+                mgf=padding.MGF1(algorithm=hashes.SHA256()),
+                algorithm=hashes.SHA256(),
+                label=None
+            )
+        )
+
+        return decrypted_bytes.decode(Constant.DEFAULT_ENCODING)
+
+        # except Exception as e:
+        #     if not silent:
+        #         logger.exception(f'Unexpected RSA decryption error: {str(e)}')
+                
+        #     raise RSAEncryptException(message=Message.UNEXPECTED_ERROR_MSG, error=str(e)) , silent: bool = False

{encryptors-2.53 → encryptors-2.54}/src/Osdental/Encryptor/Sha512.py

@@ -1,5 +1,5 @@
 import hashlib
-from Osdental.Shared.Enums.Constant import Constant
+from Osdental.Constants.Constant import Constant
 
 class SHA512:
 
@@ -7,8 +7,8 @@ class SHA512:
     def hash_password(password: str) -> str:
         """Generates the SHA-512 hash of a password."""
         hash_object = hashlib.sha512(password.encode(Constant.DEFAULT_ENCODING))
-        hashed_password = hash_object.hexdigest()
-        return hashed_password
+        return hash_object.hexdigest()
+    
 
     @staticmethod
     def verify_password(hash_password: str, password: str) -> bool:

{encryptors-2.53 → encryptors-2.54}/src/Osdental/Exception/ControlledException.py

@@ -59,56 +59,14 @@ class DatabaseConnectionException(OSDException):
 class DatabaseException(OSDException):
     def __init__(
         self, 
-        message: str = Message.UNEXPECTED_ERROR_MSG, 
+        message: str = None, 
         error: str = None, 
         status_code: str = StatusCode.DATA_NOT_FOUND_WARNING,
     ):
-        super().__init__(message=message, error=error, status_code=status_code)
-
-class RSAEncryptException(OSDException):
-    def __init__(
-        self, 
-        message: str = Message.UNEXPECTED_ERROR_MSG, 
-        error: str = None, 
-        status_code: str = StatusCode.INTERNAL_SERVER_ERROR,
-    ):
-        super().__init__(message=message, error=error, status_code=status_code)
+        self.message = message or Message.UNEXPECTED_ERROR_MSG
 
-class AESEncryptException(OSDException):
-    def __init__(
-        self, 
-        message: str = Message.UNEXPECTED_ERROR_MSG, 
-        error: str = None, 
-        status_code: str = StatusCode.INTERNAL_SERVER_ERROR,
-    ):
         super().__init__(message=message, error=error, status_code=status_code)
 
-class JWTokenException(OSDException):
-    def __init__(
-        self, 
-        message: str = Message.UNEXPECTED_ERROR_MSG, 
-        error: str = None, 
-        status_code: str = StatusCode.INTERNAL_SERVER_ERROR,
-    ):
-        super().__init__(message=message, error=error, status_code=status_code)
-
-class AzureException(OSDException):
-    def __init__(
-        self, 
-        message: str = Message.UNEXPECTED_ERROR_MSG, 
-        error: str = None, 
-        status_code: str = StatusCode.INTERNAL_SERVER_ERROR,
-    ):
-        super().__init__(message=message, error=error, status_code=status_code)
-
-class RedisException(OSDException):
-    def __init__(
-        self, 
-        message: str = Message.UNEXPECTED_ERROR_MSG, 
-        error: str = None, 
-        status_code: str = StatusCode.INTERNAL_SERVER_ERROR,
-    ):
-        super().__init__(message=message, error=error, status_code=status_code)
 
 class ValidationDataException(OSDException):
     def __init__(

{encryptors-2.53 → encryptors-2.54}/src/Osdental/Graphql/Extensions/AuditExtension.py

@@ -11,7 +11,7 @@ from Osdental.Rest.Context.RequestContext import (
 )
 from Osdental.Models.Response import Response
 from Osdental.Graphql.Models import BaseGraphQLContext
-from Osdental.Shared.Enums.Constant import Constant
+from Osdental.Constants.Constant import Constant
 
 logger = logging.getLogger(__name__)
 

{encryptors-2.53 → encryptors-2.54}/src/Osdental/Graphql/_Helpers/_TenantPolicy.py

@@ -4,7 +4,7 @@ from graphql import OperationType
 from starlette.datastructures import Headers
 from Osdental.Encryptor.Aes import AES
 from Osdental.Models.Token import AuthToken
-from Osdental.Shared.Enums.Profile import Profile
+from Osdental.Enums.Profile import Profile
 
 class TenantPolicy:
 

{encryptors-2.53 → encryptors-2.54}/src/Osdental/Helpers/AuditDispatcher.py

@@ -10,7 +10,7 @@ from Osdental.Helpers.ResponseDecryptor import decryptor_data, VALID_TYPES
 from Osdental.Models._Audit import Audit
 from Osdental.Models.Response import Response
 from Osdental.Models.ApiResponse import ApiResponse
-from Osdental.Shared.Enums.Constant import Constant
+from Osdental.Constants.Constant import Constant
 
 
 logger = logging.getLogger(__name__)

{encryptors-2.53 → encryptors-2.54}/src/Osdental/Helpers/_AuthTokenProcessor.py

@@ -5,7 +5,7 @@ from graphql import OperationType
 from starlette.datastructures import Headers
 from Osdental.Encryptor.Aes import AES
 from Osdental.Models.Token import AuthToken
-from Osdental.Shared.Enums.Profile import Profile
+from Osdental.Enums.Profile import Profile
 from Osdental.Models.TokenClaims import UserTokenClaims
 
 def extract_bearer_token(headers: Headers) -> str:

{encryptors-2.53 → encryptors-2.54}/src/Osdental/Http/APIClient.py

@@ -8,7 +8,7 @@ from Osdental.Http._Helpers import (
     audit_unknown_error, audit_graphql_error
 )
 from Osdental.Exception.ControlledException import HttpClientException
-
+from Osdental.Enums.StatusCode import StatusCode
 
 logger = logging.getLogger(__name__)
 
@@ -52,7 +52,7 @@ class APIClient:
             
             audit_http_error(exc.response, method, url, kwargs)
             raise HttpClientException(
-                status_code=exc.response.status_code,
+                status_code=StatusCode.BAD_GATEWAY,
                 error=exc.response.text
             ) from exc
         
@@ -60,7 +60,7 @@ class APIClient:
 
             audit_exception_error(exc, method, url, kwargs)
             raise HttpClientException(
-                status_code=0,
+                status_code=StatusCode.GATEWAY_TIMEOUT,
                 error=str(exc)
             ) from exc