dapper-sqls 0.9.7__py3-none-any.whl → 1.2.0__py3-none-any.whl

dapper_sqls/http/models.py

@@ -0,0 +1,58 @@
+from enum import Enum
+from pydantic import BaseModel, Field
+from typing import Optional, Literal
+
+class DataFetchHttpResult(BaseModel):
+    name : str = Field(..., description="")
+    success : bool  = Field(..., description="")
+    content : dict | list[dict] = Field(..., description="")
+    status_code : int = Field(..., description="")
+    delay : float = Field(..., description="")
+
+class HttpMethod(Enum):
+    GET = "Get"
+    POST = "Post"
+    PUT = "Put"
+    DELETE = "Delete"
+
+class DataFetchHttp:
+    def __init__(self, name : str, endpoint : str, http_method : HttpMethod, data : dict = {}):
+        self.name = name
+        self.endpoint = endpoint
+        self.http_method = http_method
+        self.data = data
+
+class BaseError(BaseModel):
+    """
+    Base class to represent errors in the system.
+    """
+    message: str = Field(..., description="A descriptive error message.")
+    status_code: Optional[int] = Field(
+        None, description="The status code associated with the error (if applicable)."
+    )
+    code: Optional[str] = Field(
+        None, description="The error code (if available)."
+    )
+    type: Optional[str] = Field(
+        None, description="The type of the error (if available)."
+    )
+
+
+class InternalServerError(BaseError):
+    """
+    Represents an internal server error.
+    """
+    message: str = Field(
+        "Internal server error", description="The error message."
+    )
+
+
+class UnavailableService(BaseError):
+    """
+    Represents an unavailable service error.
+    """
+    message: Literal["Database unavailable"] = Field(
+        "Database unavailable", description="The unavailable service message."
+    )
+
+

dapper_sqls/http/request.py

@@ -0,0 +1,140 @@
+# coding: utf-8
+from .models import HttpMethod, UnavailableService, DataFetchHttpResult, DataFetchHttp
+from time import perf_counter
+import requests
+from concurrent.futures import ThreadPoolExecutor
+from typing import overload
+from urllib.parse import urlparse
+import jwt
+from datetime import datetime
+import re
+
+class Request(object):
+
+    @staticmethod
+    def is_valid_jwt(token: str) -> bool:
+        """Verifica se uma string tem o formato de um JWT"""
+        parts = token.split(".")
+        if len(parts) != 3:
+            return False  # Deve ter exatamente 3 partes
+        
+        try:
+            # Apenas decodifica sem verificar a assinatura
+            jwt.decode(token, options={"verify_signature": False})
+            return True  # Decodificação sem erro -> é um JWT válido
+        except jwt.DecodeError:
+            return False  # Não é um JWT válido
+        except jwt.ExpiredSignatureError:
+            return True  # É um JWT, mas está expirado
+        except jwt.InvalidTokenError:
+            return False  # Token inválido
+        
+    def get_token_expiration(token: str) -> datetime | None:
+        """Obtém a data de expiração (exp) de um JWT sem precisar validar a assinatura."""
+        try:
+            decoded = jwt.decode(token, options={"verify_signature": False})  # Decodifica sem verificar
+            exp_timestamp = decoded.get("exp")  # Obtém o timestamp de expiração
+            if exp_timestamp:
+                return datetime.utcfromtimestamp(exp_timestamp)  # Converte para datetime
+        except jwt.DecodeError:
+            return None  # Token inválido
+
+        return None  # Token sem expiração definida
+
+    @staticmethod
+    def is_valid_url(url: str) -> bool:
+        parsed_url = urlparse(url)
+        
+        # Verifica se o esquema (scheme) é http ou https e se há um domínio válido
+        if parsed_url.scheme not in {"http", "https"} or not parsed_url.netloc:
+            return False
+        
+        # Regex para verificar um domínio válido
+        domain_pattern = re.compile(
+            r"^(?:[a-zA-Z0-9-]{1,63}\.)+[a-zA-Z]{2,63}$"
+        )
+        
+        return bool(domain_pattern.match(parsed_url.netloc))
+    
+    def __init__(self, base_url = "http://127.0.0.1:8000/", raise_error = False):
+        self.base_url = base_url
+        self.headers = {'Content-Type': 'application/json'}
+        self.endpoint_test_connection = 'test-connection'
+        self.raise_error = raise_error
+
+    def test_connection(self):
+        try:
+            response = requests.get(f"{self.base_url}{self.endpoint_test_connection}")
+            if response.status_code == 200:
+                return True
+        except:
+            ...
+
+    @overload
+    def fetch(self, endpoint : str, http_method : HttpMethod, data : dict = {}) -> DataFetchHttpResult:
+         pass
+
+    @overload
+    def fetch(self, endpoint : str, http_method : HttpMethod) -> DataFetchHttpResult:
+         pass
+
+    @overload
+    def fetch(self, data_fetch_http : DataFetchHttp) -> DataFetchHttpResult:
+        pass
+
+    def fetch(self, *args) -> DataFetchHttpResult:
+        if len(args) > 1:
+            if len(args) == 3:
+                endpoint, http_method, data = args 
+            else:
+                endpoint, http_method = args
+                data = {}
+            data_fetch_http = DataFetchHttp("", endpoint, http_method, data)
+        else:
+            data_fetch_http = args[0]
+   
+        url = f'{self.base_url}{data_fetch_http.endpoint}'
+
+        try:
+            method = requests.get 
+            if data_fetch_http.http_method == HttpMethod.POST:
+                method = requests.post
+            elif data_fetch_http.http_method == HttpMethod.PUT:
+                method = requests.put
+            elif data_fetch_http.http_method == HttpMethod.DELETE:
+                method = requests.delete
+
+            start = perf_counter()
+            res = method(url, json=data_fetch_http.data, headers=self.headers)
+            
+            stop = perf_counter()
+            delay = round(stop - start, 3)
+
+            content = res.json() if res.headers.get("Content-Type") == "application/json" else {"text": res.text}
+            if res.status_code == 200:
+                return DataFetchHttpResult(name=data_fetch_http.name, success=True, content=content, status_code=res.status_code, delay=delay)
+            elif res.status_code == 503:
+                if self.raise_error:
+                    raise UnavailableService()
+                else:
+                    return DataFetchHttpResult(name=data_fetch_http.name, success=False, status_code=503, content={'error': 'Database unavailable'}, delay=delay)
+            return DataFetchHttpResult(name=data_fetch_http.name, success=False, content=content, status_code=res.status_code, delay=delay)
+        except requests.exceptions.RequestException as e:
+            stop = perf_counter()
+            delay = round(stop - start, 3)
+            return DataFetchHttpResult(
+                name=data_fetch_http.name,
+                success=False,
+                content={"error": str(e)}, 
+                status_code=0, 
+                delay=delay
+            )
+
+    def fetch_all(self, list_data_fetch_http: list[DataFetchHttp]) -> dict[str, DataFetchHttpResult]:
+
+        with ThreadPoolExecutor() as executor:
+            results = executor.map(self.fetch, list_data_fetch_http)
+
+        all_results = list(results)
+        results_dict = {result.name: result for result in all_results}
+        return results_dict 

dapper_sqls/models/__init__.py

@@ -1,8 +1,6 @@
 from .http import UnavailableServiceException
 from .result import Result
 from .connection import ConnectionStringData
-from .base import TableBaseModel, BaseUpdate
-
-
-
-
+from .base import TableBaseModel, BaseUpdate, SensitiveFields, SearchTable, JoinSearchTable
+from .query_field import (StringQueryField, NumericQueryField, BoolQueryField, DateQueryField, BytesQueryField, QueryFieldBase,
+                          BaseJoinConditionField, JoinNumericCondition, JoinStringCondition, JoinBooleanCondition, JoinDateCondition, JoinBytesCondition)

dapper_sqls/models/base.py

@@ -1,35 +1,261 @@
-from pydantic import BaseModel, BaseConfig
-from abc import ABC
+from pydantic import BaseModel, ConfigDict, PrivateAttr, Field, create_model
 from abc import ABC, abstractmethod
-from .result import Result
+from typing import Set, Any, ClassVar, get_origin, get_args, Union, Optional, Literal, get_type_hints, List
+from ..utils import get_dict_args
+from dataclasses import asdict
+import copy
+import datetime
+
+QUERY_FIELD_TYPES = {
+    'StringQueryField',
+    'NumericQueryField',
+    'BoolQueryField',
+    'DateQueryField',
+    'BytesQueryField',
+    'JoinStringCondition',
+    'JoinNumericCondition',
+    'JoinBooleanCondition',
+    'JoinDateCondition',
+    'JoinBytesCondition',  
+}
+
+def convert_datetime_date_to_str(annotation):
+    """Convert datetime/date or their unions with str to just str."""
+    if annotation in (datetime.datetime, datetime.date):
+        return str
+    origin_inner = get_origin(annotation)
+    args_inner = get_args(annotation)
+    if origin_inner is Union:
+        set_args = set(args_inner)
+        if str in set_args and (datetime.datetime in set_args or datetime.date in set_args):
+            return str
+    return annotation
+
+def remove_query_field_types(annotation):
+    """
+    Remove os tipos de QueryField (como StringQueryField) de uma Union ou substitui diretamente
+    """
+    origin = get_origin(annotation)
+    args = get_args(annotation)
+
+    def is_query_field(arg):
+        return getattr(arg, '__name__', '') in QUERY_FIELD_TYPES
+
+    if origin is Union:
+        new_args = tuple(arg for arg in args if not is_query_field(arg))
+        if len(new_args) == 1:
+            return new_args[0]
+        return Union[new_args]
+    elif is_query_field(annotation):
+        return str  # fallback para str caso algum passe isolado
+    return annotation
+
+def is_optional(annotation):
+    """Check if an annotation is Optional[...] or Union[..., None]."""
+    origin = get_origin(annotation)
+    args = get_args(annotation)
+    return origin is Union and type(None) in args
+
+def remove_optional(annotation):
+    """Remove NoneType from Union[...]"""
+    args = tuple(arg for arg in get_args(annotation) if arg is not type(None))
+    if len(args) == 1:
+        return args[0]
+    return Union[args]
+
+def make_optional(annotation):
+    """Make an annotation optional if not already."""
+    if is_optional(annotation):
+        return annotation
+    return Optional[annotation]
+
+class SensitiveFields(object):
+
+    _sensitive_fields : Set[str] = set()
+
+    @classmethod
+    def set(cls, new_sensitive_filds : Set[str]):
+        cls._sensitive_fields = new_sensitive_filds
+
+    @classmethod
+    def get(cls):
+        return cls._sensitive_fields
+    
 
 class TableBaseModel(BaseModel, ABC): 
-    class Config(BaseConfig):
+    class Config(ConfigDict):
         from_attributes = True
 
-    _TABLE_NAME: str = ''
+    TABLE_NAME: ClassVar[str] 
 
-    @property
-    def TABLE_NAME(cls) -> str:
-        return cls._TABLE_NAME
+    TABLE_ALIAS: ClassVar[str] 
+
+    DESCRIPTION : ClassVar[str] 
+    
+    IDENTITIES : ClassVar[Set[str]]
+
+    PRIMARY_KEYs : ClassVar[Set[str]]
+
+    OPTIONAL_FIELDS : ClassVar[Set[str]]
+
+    MAX_LENGTH_FIELDS: ClassVar[dict[str, int]] = {}
+
+    _explicit_fields:  Set[str] = PrivateAttr(default_factory=set)
+    _pending_updates: dict[str, Any] = PrivateAttr(default_factory=dict)
+    _initial_values: dict[str, Any] = PrivateAttr(default_factory=dict)
+   
+
+    def __init__(self, **data):
+        sensitive = SensitiveFields.get()
+        filtered_data = {k: v for k, v in data.items() if k not in sensitive}
+        
+        super().__init__(**filtered_data)
+        self._explicit_fields = set(filtered_data.keys())
+        self._initial_values = copy.deepcopy(self.model_dump())
+    
+    def _reset_defaults(self):
+        for field_name, model_field in self.model_fields.items():
+            if field_name not in self._explicit_fields:
+                setattr(self, field_name, None)
+
+    def reset_to_initial_values(self):
+        for key, value in self._initial_values.items():
+            setattr(self, key, copy.deepcopy(value))
+        self.clear_updates()
+
+    def equals(self, other: "TableBaseModel") -> bool:
+        return self.model_dump() == other.model_dump()
+
+    def clear_updates(self):
+        self._pending_updates.clear()
 
+    def has_updates(self) -> bool:
+        for key, new_value in self._pending_updates.items():
+            if key in self.model_fields:
+                current_value = getattr(self, key, None)
+
+            if isinstance(current_value, BaseModel) and isinstance(new_value, BaseModel):
+                if current_value.model_dump() != new_value.model_dump():
+                    return True
+                
+            elif hasattr(current_value, "__dataclass_fields__") and hasattr(new_value, "__dataclass_fields__"):
+                if asdict(current_value) != asdict(new_value):
+                    return True
+
+            elif hasattr(current_value, "__dict__") and hasattr(new_value, "__dict__"):
+                if vars(current_value) != vars(new_value):
+                    return True
+
+            elif new_value != current_value:
+                return True
+        return False
+
+    @staticmethod
+    def queue_update(self : 'TableBaseModel', **fields):
+        fields = get_dict_args(fields)
+        for key, value in fields.items():
+            if value != None and key in self.model_fields:
+                self._pending_updates[key] = value
+
+    def apply_updates(self):
+        for key, value in self._pending_updates.items():
+            if key in self.model_fields:
+                setattr(self, key, value)
+        self.clear_updates()
+
+    def alter_model_class(self, remove_fields: tuple[str] = (), mode: Literal['all_optional', 'all_required', 'original'] = 'all_optional', query_field = False):
+        fields = {}
+        
+        for field_name, field in self.model_fields.items():
+            if field_name in remove_fields:
+                continue
+
+            ann = convert_datetime_date_to_str(field.annotation)
+            if not query_field:
+                ann = remove_query_field_types(ann)
+
+            max_length = None
+            if mode in ('all_required', 'original'):
+                max_length = self.MAX_LENGTH_FIELDS.get(field_name)
+                if isinstance(max_length, int) and max_length < 1:
+                    max_length = None
+
+            default = field.default
+
+            if mode == 'all_optional':
+                ann = make_optional(ann)
+                default = None
+
+            elif mode == 'all_required':
+                if is_optional(ann):
+                    ann = remove_optional(ann)
+                default = ...
+
+            elif mode == 'original':
+                if field_name in self.OPTIONAL_FIELDS:
+                    ann = make_optional(ann)
+                    default = None
+                else:
+                    if is_optional(ann):
+                        ann = remove_optional(ann)
+                    default = ...
+
+            fields[field_name] = (ann, Field(default=default, description=field.description, max_length=max_length))
+
+        new_model_class = create_model(
+            self.__name__,
+            __config__=ConfigDict(extra='forbid'),
+            **fields
+        )
+        return new_model_class
+    
+    @classmethod
+    def get_field_type_names(cls) -> dict[str, set[str]]:
+        result = {}
+        type_hints = get_type_hints(cls, include_extras=True)
+
+        for field_name, hint in type_hints.items():
+            if field_name.startswith('_') or get_origin(hint) is ClassVar:
+                continue
+
+            args = get_args(hint)
+            if not args:
+                args = (hint,)
+
+            types = {
+                t.__name__ if hasattr(t, '__name__') else t._name if hasattr(t, '_name') else str(t)
+                for t in args
+                if t is not type(None)  
+            }
+
+            result[field_name] = types
+
+        return result
+    
+class SearchTable(BaseModel):
+    model: TableBaseModel
+    include: Optional[List[str]] = Field(default_factory=list)
+ 
+class JoinSearchTable(SearchTable):
+    join_type: Literal["INNER", "LEFT", "RIGHT", "FULL"] = "LEFT"
+    
 class BaseUpdate(ABC):
 
-        def __init__(self, executor , model):
-            self._set_data = model
-            self._executor = executor
+    def __init__(self, executor , model):
+        self._set_data = model
+        self._executor = executor
 
-        @property
-        def set_data(self):
-            return self._set_data
+    @property
+    def set_data(self):
+        return self._set_data
 
-        @property
-        def executor(self):
-            return self._executor
+    @property
+    def executor(self):
+        return self._executor
 
-        @abstractmethod
-        def where(self, *args)  -> Result.Send:
-            pass
+    @abstractmethod
+    def where(self, *args):
+        pass
 
 
 

dapper_sqls/models/connection.py

@@ -1,4 +1,4 @@
-# -*- coding: latin -*-
+# coding: utf-8
 
 class ConnectionStringData(object):
     def __init__(self, server: str, database: str, username: str, password: str):
@@ -34,7 +34,7 @@ class ConnectionStringData(object):
     @username.setter
     def username(self, value: str):
         if not isinstance(value, str):
-            raise ValueError("O nome de usu�rio deve ser uma string.")
+            raise ValueError("O nome de usuário deve ser uma string.")
         self._username = value
 
     @property