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

dapper_sqls/http/aiohttp.py

@@ -0,0 +1,155 @@
+# coding: utf-8
+
+import asyncio
+from time import perf_counter
+import aiohttp
+from .models import HttpMethod, UnavailableService, DataFetchHttpResult, DataFetchHttp
+from typing import overload
+import re
+from urllib.parse import urlparse
+import jwt
+from datetime import datetime
+
+class AioHttp(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
+
+    async def test_connection(self):
+        data = DataFetchHttp("test-connection", self.endpoint_test_connection, HttpMethod.GET )
+        try:
+            res = await self.fetch(data)
+            if res.success:
+                return True
+        except:
+            ...
+
+    @overload
+    async def fetch(self, data: DataFetchHttp, session: aiohttp.ClientSession) -> DataFetchHttpResult:
+        pass
+
+    @overload
+    async def fetch(self, data: DataFetchHttp) -> DataFetchHttpResult:
+        pass
+
+    @overload
+    async def fetch(self, endpoint : str, http_method : HttpMethod, data : dict = {}) -> DataFetchHttpResult:
+         pass
+
+    @overload
+    async def fetch(self, endpoint : str, http_method : HttpMethod) -> DataFetchHttpResult:
+         pass
+
+    async def fetch(self, *args) -> DataFetchHttpResult:
+        if type(args[0]) == str:
+            if len(args) == 3:
+                endpoint, http_method, data = args 
+            else:
+                endpoint, http_method = args
+                data = {}
+            data_fetch_http = DataFetchHttp("", endpoint, http_method, data)
+            async with aiohttp.ClientSession() as session:
+                return await self._do_fetch(data_fetch_http, session)
+        else:
+            data_fetch_http = args[0]
+            if len(args) == 1:
+                async with aiohttp.ClientSession() as session:
+                    return await self._do_fetch(data_fetch_http, session)
+            else:
+                session = args[1]
+                return await self._do_fetch(data_fetch_http, session)
+
+    async def _do_fetch(self, data_fetch_http: DataFetchHttp, session: aiohttp.ClientSession) -> DataFetchHttpResult:
+        url = f'{self.base_url}{data_fetch_http.endpoint}'
+
+        try:
+            method = session.get 
+            if data_fetch_http.http_method == HttpMethod.POST:
+                method = session.post
+            elif data_fetch_http.http_method == HttpMethod.PUT:
+                method = session.put
+            elif data_fetch_http.http_method == HttpMethod.DELETE:
+                method = session.delete
+
+            start = perf_counter()
+            async with method(url, headers=self.headers, json=data_fetch_http.data) as r:
+                content = await r.json() if r.headers.get("Content-Type") == "application/json" else {"text": await r.text()}
+
+            stop = perf_counter()
+            delay = round(stop - start, 3)
+            if r.status == 200:
+                return DataFetchHttpResult(name=data_fetch_http.name, success=True, content=content, status_code=r.status, delay=delay)
+            elif r.status == 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=r.status, delay=delay)
+        except aiohttp.ClientError 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
+            )
+
+    async def fetch_all(self, list_data_fetch_http: list[DataFetchHttp]) -> dict[str, DataFetchHttpResult]:
+        async with aiohttp.ClientSession() as session:
+            tasks = [self.fetch(data, session) for data in list_data_fetch_http]
+            res = await asyncio.gather(*tasks)
+            return {t.name: t for t in res}
+
+
+
+

dapper_sqls/http/decorators.py

@@ -0,0 +1,123 @@
+# coding: utf-8
+from functools import wraps
+import asyncio
+from time import perf_counter
+from .models import UnavailableService, InternalServerError
+import http
+from collections.abc import Mapping
+from typing_extensions import Annotated, Doc
+from typing import Any, Dict, Optional
+
+class StarletteHTTPException(Exception):
+    def __init__(self, status_code: int, detail: str | None = None, headers: Mapping[str, str] | None = None) -> None:
+        if detail is None:
+            detail = http.HTTPStatus(status_code).phrase
+        self.status_code = status_code
+        self.detail = detail
+        self.headers = headers
+
+    def __str__(self) -> str:
+        return f"{self.status_code}: {self.detail}"
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        return f"{class_name}(status_code={self.status_code!r}, detail={self.detail!r})"
+
+class HTTPException(StarletteHTTPException):
+    """
+    An HTTP exception you can raise in your own code to show errors to the client.
+
+    This is for client errors, invalid authentication, invalid data, etc. Not for server
+    errors in your code.
+
+    Read more about it in the
+    [FastAPI docs for Handling Errors](https://fastapi.tiangolo.com/tutorial/handling-errors/).
+
+    ## Example
+
+    ```python
+    from fastapi import FastAPI, HTTPException
+
+    app = FastAPI()
+
+    items = {"foo": "The Foo Wrestlers"}
+
+
+    @app.get("/items/{item_id}")
+    async def read_item(item_id: str):
+        if item_id not in items:
+            raise HTTPException(status_code=404, detail="Item not found")
+        return {"item": items[item_id]}
+    ```
+    """
+
+    def __init__(
+        self,
+        status_code: Annotated[
+            int,
+            Doc(
+                """
+                HTTP status code to send to the client.
+                """
+            ),
+        ],
+        detail: Annotated[
+            Any,
+            Doc(
+                """
+                Any data to be sent to the client in the `detail` key of the JSON
+                response.
+                """
+            ),
+        ] = None,
+        headers: Annotated[
+            Optional[Dict[str, str]],
+            Doc(
+                """
+                Any headers to send to the client in the response.
+                """
+            ),
+        ] = None,
+    ) -> None:
+        super().__init__(status_code=status_code, detail=detail, headers=headers)
+
+def _create_error(e : Exception):
+    error_message = str(e)
+    error_type = None
+    error_code = None
+    error_status_code = None
+
+    if hasattr(e , 'message'):
+        error_message = e.message
+    if hasattr(e, 'type'):
+        error_type = e.type
+    if hasattr(e, 'code'):
+        error_code = e.code
+    if hasattr(e, 'status_code'):
+        error_status_code = e.status_code
+
+    return InternalServerError(message=error_message, status_code=error_status_code, type=error_type, code=error_code)
+
+def func_router_validation(use_log = True):
+    def decorator(func):
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            if use_log:
+                start = perf_counter()
+            try:
+                return await asyncio.create_task(func(*args, **kwargs))
+            except Exception as e:
+                error = _create_error(e)
+                if error.status_code == 503:
+                    raise HTTPException(status_code=503, detail=UnavailableService().model_dump())
+                
+                raise HTTPException(status_code=500, detail=error.model_dump())
+            finally:
+                if use_log:
+                    stop = perf_counter()
+                    execution_time = round(stop - start, 3)
+                    print(f"The function '{func.__name__}' executed in {execution_time} seconds.")
+
+        return wrapper
+
+    return decorator

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)