konecty-sdk-python 0.1.0__py3-none-any.whl

lib/filters.py

@@ -0,0 +1,155 @@
+from datetime import datetime
+from enum import Enum
+from typing import Any, Dict, List, Optional, Union
+
+from pydantic import BaseModel, Field
+
+
+class FilterMatch(str, Enum):
+    """Tipo de correspondência do filtro."""
+
+    AND = "and"
+    OR = "or"
+
+
+class FilterOperator(str, Enum):
+    """Operadores disponíveis para filtros."""
+
+    EQUALS = "equals"
+    NOT_EQUALS = "not_equals"
+    STARTS_WITH = "starts_with"
+    END_WITH = "end_with"
+    CONTAINS = "contains"
+    NOT_CONTAINS = "not_contains"
+    LESS_THAN = "less_than"
+    GREATER_THAN = "greater_than"
+    LESS_OR_EQUALS = "less_or_equals"
+    GREATER_OR_EQUALS = "greater_or_equals"
+    BETWEEN = "between"
+    IN = "in"
+    NOT_IN = "not_in"
+    EXISTS = "exists"
+
+
+class DateValue(BaseModel):
+    """Valor de data para filtros."""
+
+    date: datetime
+
+
+class BetweenValue(BaseModel):
+    """Valor para filtros do tipo between."""
+
+    greater_or_equals: Union[int, float, DateValue, datetime, None]
+    less_or_equals: Union[int, float, DateValue, datetime, None]
+
+
+class FilterCondition(BaseModel):
+    """Condição de filtro."""
+
+    term: str = Field(..., description="Campo a ser filtrado")
+    operator: FilterOperator = Field(..., description="Operador de comparação")
+    value: Any = Field(..., description="Valor para comparação")
+    disabled: bool = Field(False, description="Se a condição está desativada")
+
+
+class KonectyFilter(BaseModel):
+    """Filtro Konecty."""
+
+    match: FilterMatch = Field(FilterMatch.AND, description="Tipo de correspondência")
+    conditions: List[FilterCondition] = Field(default_factory=list, description="Lista de condições")
+    filters: List["KonectyFilter"] = Field(default_factory=list, description="Lista de filtros aninhados")
+
+    def to_json(self) -> Dict[str, Any]:
+        """Converte o filtro para formato JSON."""
+        return self.model_dump(mode="json")
+    
+    def is_empty(self) -> bool:
+        """Verifica se o filtro está vazio."""
+        return len(self.conditions) == 0 and len(self.filters) == 0
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "KonectyFilter":
+        """Converte dicionário para filtro."""
+        return cls(**data)
+
+    @classmethod
+    def create(cls, match: Union[FilterMatch, str] = FilterMatch.AND) -> "KonectyFilter":
+        """Cria uma nova instância de filtro.
+
+        Args:
+            match: Tipo de correspondência ("and" ou "or")
+
+        Returns:
+            Nova instância de KonectyFilter
+        """
+        if isinstance(match, str):
+            match = FilterMatch(match.lower())
+        return cls(match=match)
+
+    def add_condition(
+        self, term: str, operator: Union[FilterOperator, str], value: Any, disabled: bool = False
+    ) -> "KonectyFilter":
+        """Adiciona uma condição ao filtro.
+
+        Args:
+            term: Campo a ser filtrado
+            operator: Operador de comparação
+            value: Valor para comparação
+            disabled: Se a condição está desativada
+
+        Returns:
+            Self para encadeamento
+        """
+        if isinstance(operator, str):
+            operator = FilterOperator(operator.lower())
+
+        self.conditions.append(
+            FilterCondition(
+                term=term,
+                operator=operator,
+                value=value,
+                disabled=disabled,
+            )
+        )
+        return self
+
+    def add_filter(self, match: Union[FilterMatch, str] = FilterMatch.AND) -> "KonectyFilter":
+        """Adiciona um filtro aninhado.
+
+        Args:
+            match: Tipo de correspondência do filtro aninhado
+
+        Returns:
+            Novo filtro aninhado
+        """
+        if isinstance(match, str):
+            match = FilterMatch(match.lower())
+
+        nested_filter = KonectyFilter(match=match)
+        self.filters.append(nested_filter)
+        return nested_filter
+
+
+class SortDirection(str, Enum):
+    """Direção da ordenação."""
+
+    ASC = "ASC"
+    DESC = "DESC"
+
+
+class SortOrder(BaseModel):
+    """Ordenação de resultados."""
+
+    property: str = Field(..., description="Campo para ordenação")
+    direction: SortDirection = Field(..., description="Direção da ordenação")
+
+
+class KonectyFindParams(BaseModel):
+    """Parâmetros para busca no Konecty."""
+
+    filter: KonectyFilter
+    start: Optional[int] = None
+    limit: Optional[int] = None
+    sort: Optional[List[SortOrder]] = None
+    fields: Optional[List[Union[str, int]]] = None

lib/model.py

@@ -0,0 +1,76 @@
+from typing import Any, Dict, List, Optional, Type, TypeVar, cast
+
+from pydantic import BaseModel, Field, create_model
+from pydantic.fields import FieldInfo
+
+from konecty.types import Address, KonectyDateTime, KonectyEmail, KonectyLookup, KonectyPersonName, KonectyPhone
+
+T = TypeVar("T")
+ModelType = TypeVar("ModelType", bound=BaseModel)
+
+
+class KonectyModelGenerator:
+    def __init__(self, schema: Dict[str, Any]):
+        self.schema = schema
+        self.type_mapping: Dict[str, Type[Any]] = {
+            "json": dict,
+            "richText": str,
+            "lookup": KonectyLookup,
+            "picklist": str,
+            "url": str,
+            "boolean": bool,
+            "text": str,
+            "dateTime": KonectyDateTime,
+            "address": Address,
+            "email": KonectyEmail,
+            "phone": KonectyPhone,
+            "personName": KonectyPersonName,
+        }
+
+    def generate_model(self, language: str = "en") -> Type[BaseModel]:
+        fields: Dict[str, tuple[Type[Any], FieldInfo]] = {}
+        for field in self.schema["fields"]:
+            field_name = field["name"]
+            field_raw_type = field["type"]
+            description = (
+                field["help"].get(language, field["help"].get("en", ""))
+                if "help" in field
+                else field["label"].get(language, field["label"].get("en", ""))
+            )
+
+            base_type = self._get_field_type(field_raw_type)
+            current_type = base_type
+
+            if field.get("isList"):
+                current_type = List[base_type]  # type: ignore
+
+            if field.get("minSelected", 1) > 1 or field.get("maxSelected", 1) > 1:
+                current_type = List[base_type]  # type: ignore
+
+            is_required = field.get("isRequired", False) or field.get("minSelected", 0) > 0
+
+            if not is_required and "defaultValue" not in field:
+                current_type = Optional[base_type]  # type: ignore
+
+            field_params = {
+                "alias": field_name,
+                "description": description,
+            }
+
+            if "defaultValue" in field:
+                field_params["default"] = field["defaultValue"]
+
+            if not is_required and "defaultValue" not in field:
+                field_params["default"] = None
+
+            fields[self._clean_name_for_pydantic(field_name)] = (current_type, Field(**field_params))
+
+        model_name = self.schema["name"]
+        return create_model(model_name, **fields)
+
+    def _clean_name_for_pydantic(self, name: str) -> str:
+        return name.replace("_", "")
+
+    def _get_field_type(self, field_type: str) -> Type[Any]:
+        result = self.type_mapping.get(field_type, Any)
+        return cast(Type[Any], result)

lib/settings.py

@@ -0,0 +1,115 @@
+"""Módulo para gerenciar configurações do Konecty."""
+
+import json
+import os
+from typing import Any, Type, TypeVar
+
+from pydantic import BaseModel
+
+from .client import KonectyClient
+
+T = TypeVar("T", bound=BaseModel)
+
+
+def _convert_value(value: str, field_type: Type[Any] | None) -> Any:
+    """Converte um valor string para o tipo correto.
+
+    Args:
+        value: Valor string a ser convertido
+        field_type: Tipo para converter o valor
+
+    Returns:
+        Valor convertido para o tipo correto
+    """
+    if field_type is None:
+        return value
+
+    try:
+        if field_type is bool:
+            return value.lower() == "true"
+        elif field_type is int:
+            return int(value)
+        elif field_type is float:
+            return float(value)
+        elif field_type is list:
+            return [item.strip() for item in value.split(",")]
+        elif field_type is dict:
+            return json.loads(value)
+        else:
+            return value
+    except (ValueError, TypeError, json.JSONDecodeError):
+        return None
+
+
+async def fill_settings(settings_class: Type[T]) -> T:
+    """Preenche as configurações de uma classe com valores do Konecty.
+
+    Args:
+        settings_class: Classe de configurações que herda de BaseModel.
+
+    Returns:
+        Instância da classe de configurações preenchida com valores do Konecty.
+    """
+    client = KonectyClient(
+        base_url=os.getenv("KONECTY_URL", "http://localhost:3000"),
+        token=os.getenv("KONECTY_TOKEN", "invalid_key"),
+    )
+
+    settings_dict = {}
+
+    for field_name in settings_class.model_fields.keys():
+        # Primeiro verifica se existe na variável de ambiente
+        env_value = os.getenv(field_name.upper())
+        if env_value is not None and env_value.strip():
+            field_type = settings_class.model_fields[field_name].annotation
+            converted_value = _convert_value(env_value, field_type)
+            if converted_value is not None:
+                settings_dict[field_name] = converted_value
+                continue
+        # Se não encontrou na variável de ambiente, busca no Konecty
+        if field_name not in settings_dict:
+            value = await client.get_setting(field_name)
+            if value is not None and value.strip():
+                field_type = settings_class.model_fields[field_name].annotation
+                converted_value = _convert_value(value, field_type)
+                if converted_value is not None:
+                    settings_dict[field_name] = converted_value
+
+    return settings_class.model_construct(**settings_dict)
+
+
+def fill_settings_sync(settings_class: Type[T]) -> T:
+    """Versão síncrona de fill_settings.
+
+    Args:
+        settings_class: Classe de configurações que herda de BaseModel.
+
+    Returns:
+        Instância da classe de configurações preenchida com valores do Konecty.
+    """
+    client = KonectyClient(
+        base_url=os.getenv("KONECTY_URL", "http://localhost:3000"),
+        token=os.getenv("KONECTY_TOKEN", "invalid_key"),
+    )
+
+    settings_dict = {}
+
+    for field_name in settings_class.model_fields.keys():
+        # Primeiro verifica se existe na variável de ambiente
+        env_value = os.getenv(field_name.upper())
+        if env_value is not None and env_value.strip():
+            field_type = settings_class.model_fields[field_name].annotation
+            converted_value = _convert_value(env_value, field_type)
+            if converted_value is not None:
+                settings_dict[field_name] = converted_value
+                continue
+        # Se não encontrou na variável de ambiente, busca no Konecty
+        if field_name not in settings_dict:
+            value = client.get_setting_sync(field_name)
+            if value is not None and value.strip():
+                field_type = settings_class.model_fields[field_name].annotation
+                converted_value = _convert_value(value, field_type)
+                if converted_value is not None:
+                    settings_dict[field_name] = converted_value
+
+    return settings_class.model_construct(**settings_dict)

lib/types.py

@@ -0,0 +1,303 @@
+import re
+from datetime import datetime
+from typing import Any, Optional, Self
+
+from pydantic import BaseModel, Field
+from pydantic.json_schema import JsonSchemaValue
+from pydantic_core import CoreSchema, core_schema
+
+
+class KonectyDateTimeError(Exception):
+    """Exceção base para erros de data/hora."""
+
+    pass
+
+
+class KonectyDateTimeFormatError(KonectyDateTimeError):
+    """Exceção para erros de formato de data/hora."""
+
+    def __init__(self):
+        super().__init__("Data em formato inválido")
+
+
+class KonectyDateTimeTypeError(KonectyDateTimeError):
+    """Exceção para erros de tipo de data/hora."""
+
+    def __init__(self):
+        super().__init__("Tipo inválido para KonectyDateTime")
+
+
+class KonectyDateTime(datetime):
+    """Classe personalizada para manipular datetime com o formato {'$date': 'ISO8601 string'}."""
+
+    @classmethod
+    def from_datetime(cls, dt: datetime) -> Self:
+        return cls(
+            dt.year,
+            dt.month,
+            dt.day,
+            dt.hour,
+            dt.minute,
+            dt.second,
+            dt.microsecond,
+            dt.tzinfo,
+        )
+
+    @classmethod
+    def from_json(cls, json: dict[str, Any]) -> Self:
+        date_str = json["$date"]
+        date = datetime.fromisoformat(date_str.replace("Z", "+00:00"))
+        return cls(
+            date.year,
+            date.month,
+            date.day,
+            date.hour,
+            date.minute,
+            date.second,
+            date.microsecond,
+            date.tzinfo,
+        )
+
+    @classmethod
+    def from_any(cls, value: Any) -> Self:
+        if isinstance(value, dict) and "$date" in value:
+            return cls.from_json(value)
+        if isinstance(value, datetime):
+            return cls.from_datetime(value)
+        if isinstance(value, str):
+            return cls.from_isoformat(value)
+        raise KonectyDateTimeTypeError
+
+    @classmethod
+    def from_isoformat(cls, value: str) -> Self:
+        date = datetime.fromisoformat(value.replace("Z", "+00:00"))
+        return cls(
+            date.year,
+            date.month,
+            date.day,
+            date.hour,
+            date.minute,
+            date.second,
+            date.microsecond,
+            date.tzinfo,
+        )
+
+    @classmethod
+    def __get_validators__(cls):
+        yield cls.validate
+
+    @classmethod
+    def validate(cls, v):
+        if isinstance(v, dict) and "$date" in v:
+            try:
+                return datetime.fromisoformat(v["$date"].replace("Z", "+00:00"))
+            except Exception as e:
+                raise KonectyDateTimeFormatError from e
+        elif isinstance(v, datetime):
+            return v
+        raise KonectyDateTimeTypeError
+
+    @classmethod
+    def __get_pydantic_core_schema__(cls, source_type: Any, handler: Any) -> CoreSchema:
+        """Define o schema para serialização/deserialização do Pydantic."""
+        return core_schema.json_or_python_schema(
+            json_schema=core_schema.typed_dict_schema(
+                {
+                    "$date": core_schema.typed_dict_field(core_schema.str_schema()),
+                },
+                total=True,
+            ),
+            python_schema=core_schema.datetime_schema(),
+            serialization=core_schema.plain_serializer_function_ser_schema(
+                lambda x: {"$date": x.isoformat()}
+            ),
+        )
+
+    @classmethod
+    def __get_pydantic_json_schema__(
+        cls, core_schema: Any, handler: Any
+    ) -> JsonSchemaValue:
+        """Define o schema JSON para documentação."""
+        json_schema = handler(core_schema)
+        json_schema.update(
+            examples=["2023-01-01T00:00:00Z"],
+            type="string",
+            format="date-time",
+        )
+        return json_schema
+
+    def to_json(self):
+        return {"$date": self.isoformat()}
+
+
+class Address(BaseModel):
+    """Representa um endereço completo.
+
+    Esta classe modela informações detalhadas de um endereço, incluindo
+    dados geográficos e informações de localização específicas.
+    """
+
+    number: str | None = Field(None, description="Número do endereço.")
+    postal_code: str | None = Field(
+        None, description="Código postal ou CEP do endereço."
+    )
+    street: str | None = Field(None, description="Nome da rua, avenida ou logradouro.")
+    district: str | None = Field(None, description="Bairro ou distrito.")
+    city: str | None = Field(None, description="Cidade.")
+    state: str | None = Field(None, description="Estado ou província.")
+    place_type: str | None = Field(
+        None, description="Tipo de logradouro (por exemplo, Rua, Avenida, Praça)."
+    )
+    complement: str | None = Field(
+        None, description="Informações complementares do endereço."
+    )
+    country: str | None = Field(None, description="País.")
+
+    def to_dict(self) -> dict[str, Any]:
+        return self.model_dump(by_alias=True)
+
+
+class KonectyUser(BaseModel):
+    """Representa um usuário do Konecty."""
+
+    id: str = Field(alias="_id")
+    name: str = Field(alias="name")
+    active: bool = Field(alias="active")
+
+
+class KonectyBaseModel(BaseModel):
+    """Modelo base para documentos do Konecty."""
+
+    id: str = Field(alias="_id")
+    created_at: KonectyDateTime = Field(alias="_createdAt")
+    created_by: KonectyUser = Field(alias="_createdBy")
+    updated_at: KonectyDateTime = Field(alias="_updatedAt")
+    updated_by: KonectyUser = Field(alias="_updatedBy")
+    user: list[KonectyUser] = Field(alias="_user")
+
+
+class KonectyLabel(BaseModel):
+    pt_br: str = Field(alias="pt_BR")
+    en: str = Field(alias="en")
+
+
+class KonectyPhone(BaseModel):
+    country_code: Optional[int] = Field(None, ge=1, le=999, alias="countryCode")
+    phone_number: Optional[str] = Field(
+        None, max_length=11, min_length=8, alias="phoneNumber"
+    )
+    type: Optional[str] = Field(
+        None,
+        description="Tipo do telefone (por exemplo, celular, fixo, comercial)",
+        alias="type",
+    )
+
+    model_config = {
+        "populate_by_name": True,
+        "extra": "allow",
+    }
+
+    @classmethod
+    def empty(cls) -> Self:
+        return cls(countryCode=None, phoneNumber=None, type=None)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Self:
+        return cls.model_validate(data)
+
+    @classmethod
+    def from_string(cls, value: str) -> Self:
+        return cls(
+            phoneNumber=re.sub(r"\D", "", value),
+            countryCode=55,
+            type="mobile",
+        )
+
+    @classmethod
+    def from_any(cls, value: Any) -> Self | None:
+        if value is None:
+            return None
+        if isinstance(value, cls):
+            return value
+        if isinstance(value, str):
+            return cls.from_string(value)
+        if isinstance(value, dict):
+            return cls.from_dict(value)
+        raise ValueError("Invalid value for KonectyPhone")
+
+    def to_dict(self) -> dict[str, Any]:
+        return self.model_dump(by_alias=True)
+
+
+class KonectyLookup(BaseModel):
+    """Representa uma referência a outro documento no Konecty."""
+
+    id: str = Field(alias="_id")
+
+
+class KonectyEmail(BaseModel):
+    """Representa um endereço de e-mail."""
+
+    address: Optional[str] = Field(None, description="Endereço de e-mail válido")
+
+    model_config = {
+        "populate_by_name": True,
+        "extra": "allow",
+    }
+
+    @classmethod
+    def empty(cls) -> Self:
+        return cls(address=None)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Self:
+        return cls.model_validate(data)
+
+    @classmethod
+    def from_string(cls, value: str) -> Self:
+        return cls(address=value)
+
+    @classmethod
+    def from_any(cls, value: Any) -> Self | None:
+        if value is None:
+            return None
+        if isinstance(value, str):
+            return cls.from_string(value)
+        if isinstance(value, dict):
+            return cls.from_dict(value)
+        if isinstance(value, cls):
+            return value
+        raise ValueError("Invalid value for KonectyEmail")
+
+    def to_dict(self) -> dict[str, Any]:
+        return self.model_dump(by_alias=True)
+
+
+class KonectyPersonName(BaseModel):
+    """Representa um nome completo de pessoa."""
+
+    first: str | None = Field(None, description="Primeiro nome")
+    last: str | None = Field(None, description="Sobrenome")
+    full: str = Field(description="Nome completo")
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Self:
+        return cls.model_validate(data)
+
+    @classmethod
+    def from_string(cls, value: str) -> Self:
+        name = value.split(" ")
+        return cls(first=name[0], last=" ".join(name[1:]), full=value)
+
+    @classmethod
+    def from_any(cls, value: Any) -> Self:
+        if isinstance(value, str):
+            return cls.from_string(value)
+        if isinstance(value, dict):
+            return cls.from_dict(value)
+        if isinstance(value, cls):
+            return value
+        raise ValueError("Invalid value for KonectyPersonName")
+
+    def to_dict(self) -> dict[str, Any]:
+        return self.model_dump(by_alias=True)