cuenca-validations 0.11.32.dev5__py3-none-any.whl → 2.0.0.dev1__py3-none-any.whl

cuenca_validations/errors.py

@@ -1,3 +1,4 @@
+'''
 __all__ = [
     'ApiError',
     'AuthMethodNotAllowedError',
@@ -7,20 +8,15 @@ __all__ = [
     'InvalidOTPCodeError',
     'MissingAuthorizationHeaderError',
     'NoPasswordFoundError',
-    'NotDigitError',
     'TooManyAttemptsError',
     'UserLocationError',
     'UserNotLoggedInError',
     'WrongCredsError',
 ]
 
-from pydantic.errors import (
-    NotDigitError as PydanticNotDigitError,
-    PydanticValueError,
-)
+from pydantic_core import PydanticCustomError
 
-
-class CardBinValidationError(PydanticValueError):
+class CardBinValidationError(PydanticCustomError):
     code = 'payment_card_number.bin'
     msg_template = (
         'The card number contains a BIN (first six digits) that does not have'
@@ -30,10 +26,6 @@ class CardBinValidationError(PydanticValueError):
     )
 
 
-class NotDigitError(PydanticNotDigitError):
-    code = 'digits'
-    msg_template = 'value is not all digits'
-
 
 class CuencaError(Exception):
     """Exceptions related to ApiKeys, Login, Password, etc"""
@@ -118,3 +110,5 @@ ERROR_CODES = {
         InvalidOTPCodeError,
     ]
 }
+
+'''

cuenca_validations/types/__init__.py

@@ -52,7 +52,6 @@ __all__ = [
     'PageSize',
     'PartnerRequest',
     'PartnerUpdateRequest',
-    'PaymentCardNumber',
     'PhoneNumber',
     'PlatformRequest',
     'PlatformType',
@@ -108,7 +107,7 @@ __all__ = [
     'get_state_name',
 ]
 
-from .card import PaymentCardNumber, StrictPaymentCardNumber
+from .card import StrictPaymentCardNumber
 from .enums import (
     AuthorizerTransaction,
     BankAccountStatus,
@@ -182,7 +181,6 @@ from .queries import (
     EventQuery,
     FileQuery,
     IdentityQuery,
-    PageSize,
     QueryParams,
     SessionQuery,
     StatementQuery,

cuenca_validations/types/card.py

@@ -1,53 +1,26 @@
-from typing import TYPE_CHECKING, ClassVar
-
-from pydantic.types import PaymentCardNumber as PydanticPaymentCardNumber
-from pydantic.validators import (
-    constr_length_validator,
-    constr_strip_whitespace,
-    str_validator,
-)
+from pydantic import BaseModel, field_validator
+from pydantic_core import PydanticCustomError
+from pydantic_extra_types.payment import PaymentCardBrand, PaymentCardNumber
 
 from ..card_bins import CARD_BINS
-from ..errors import CardBinValidationError
-
-if TYPE_CHECKING:
-    from pydantic.typing import CallableGenerator
-
-
-class PaymentCardNumber(PydanticPaymentCardNumber):
-    min_length: ClassVar[int] = 16
-    max_length: ClassVar[int] = 16
-
-    def __init__(self, card_number: str):
-        self.bin = card_number[:6]
-        self.last4 = card_number[-4:]
-        self.brand = self._get_brand(card_number)
-        self.bank_code = CARD_BINS.get(self.bin)
 
-    @classmethod
-    def __get_validators__(cls) -> 'CallableGenerator':
-        yield str_validator
-        yield constr_strip_whitespace
-        yield constr_length_validator
-        yield cls.validate_digits
-        yield cls.validate_luhn_check_digit
-        yield cls
 
+class StrictPaymentCardNumber(BaseModel):
 
-class StrictPaymentCardNumber(PaymentCardNumber):
-    """
-    requires that the BIN be associated to a known BIN for a Mexican bank
-    """
+    card_number: PaymentCardNumber
 
-    bank_code: str
-
-    @classmethod
-    def __get_validators__(cls) -> 'CallableGenerator':
-        yield from PaymentCardNumber.__get_validators__()
-        yield cls.validate_bin
-
-    @classmethod
+    @field_validator('card_number')
     def validate_bin(cls, card_number: PaymentCardNumber) -> PaymentCardNumber:
-        if card_number.bank_code is None:
-            raise CardBinValidationError
+        if card_number.bin not in CARD_BINS:
+            raise PydanticCustomError(
+                'payment_card_number.bin', 'Invalid BIN: Bank code not found.'
+            )
         return card_number
+
+    @property
+    def brand(self) -> PaymentCardBrand:
+        return self.card_number.brand
+
+    @property
+    def bank_code(self) -> str:
+        return CARD_BINS[self.card_number.bin]

cuenca_validations/types/enums.py

@@ -570,6 +570,7 @@ class UserStatus(str, Enum):
     in_review = 'in_review'
     pld_blocked = 'pld_blocked'
     inactive = 'inactive'
+    user_blocked = 'user_blocked'
 
 
 class SessionType(str, Enum):
@@ -678,8 +679,3 @@ class SATRegimeCode(str, Enum):
     ING_PREM = "615"  # Régimen de los ingresos por obtención de premios
     AE_PLAT_TEC = "625"  # Régimen de las Actividades Empresariales con ingresos a través de Plataformas Tecnológicas # noqa: E501
     RS_CONF = "626"  # Régimen Simplificado de Confianza
-
-
-class PasswordType(str, Enum):
-    numeric = 'numeric'
-    alphanumeric = 'alphanumeric'

cuenca_validations/types/files.py

@@ -1,12 +1,12 @@
 from typing import Optional
 
-from pydantic import BaseModel, HttpUrl
+from pydantic import AnyHttpUrl, BaseModel
 
 from .enums import KYCFileType
 
 
 class BatchFileMetadata(BaseModel):
-    id: Optional[str]
+    id: Optional[str] = None
     is_back: bool
     type: KYCFileType
-    url: HttpUrl
+    url: AnyHttpUrl

cuenca_validations/types/general.py

@@ -1,14 +1,12 @@
 import json
-from typing import TYPE_CHECKING, Optional, Type
+from typing import Generator, Optional
 
-from pydantic import ConstrainedFloat, ConstrainedInt, ConstrainedStr
+from pydantic import BeforeValidator, Field
+from typing_extensions import Annotated
 
-from ..validators import sanitize_dict, sanitize_item, validate_digits
+from ..validators import sanitize_dict, sanitize_item
 from .enums import State
 
-if TYPE_CHECKING:
-    from pydantic.typing import CallableGenerator
-
 
 class SantizedDict(dict):
     def __init__(self, *args, **kwargs):
@@ -21,43 +19,63 @@ class JSONEncoder(json.JSONEncoder):
         return sanitize_item(o, default=super().default)
 
 
-class StrictPositiveInt(ConstrainedInt):
-    """
-    - strict: ensures a float isn't passed in by accident
-    - gt (greater than): ensures the value is strictly above 0
-    """
+def validate_strict_positive_int(value: int) -> int:
+    if not isinstance(value, int):
+        raise ValueError("Value must be an integer")
+    if value <= 0:
+        raise ValueError("Value must be greater than 0")
+    if value > 21_474_836_47:
+        raise ValueError("Value must be less than 21_474_836_47")
+    return value
 
-    strict = True
-    gt = 0
-    le = 21_474_836_47  # Max value in DB
 
-    ...
+StrictPositiveInt = Annotated[
+    int, BeforeValidator(validate_strict_positive_int)
+]
 
 
-class StrictPositiveFloat(ConstrainedFloat):
-    """
-    - strict: ensures an integer isn't passed in by accident
-    - ge (greater than or equal): ensures the value is above 0
-    """
+def validate_strict_positive_float(value: float) -> float:
+    if not isinstance(value, float):
+        raise ValueError("Value must be a float")
+    if value <= 0:
+        raise ValueError("Value must be greater than 0")
+    return value
 
-    strict = True
-    ge = 0
 
-    ...
+StrictPositiveFloat = Annotated[
+    float, BeforeValidator(validate_strict_positive_float)
+]
 
 
-def digits(
-    min_length: Optional[int] = None, max_length: Optional[int] = None
-) -> Type[str]:
-    namespace = dict(min_length=min_length, max_length=max_length)
-    return type('DigitsValue', (Digits,), namespace)
+# Clase base para validación
+class Digits:
+    min_length: Optional[int] = None
+    max_length: Optional[int] = None
 
+    @classmethod
+    def __get_validators__(cls) -> Generator:
+        yield cls.validate_digits
 
-class Digits(ConstrainedStr):
     @classmethod
-    def __get_validators__(cls) -> 'CallableGenerator':
-        yield from ConstrainedStr.__get_validators__()
-        yield validate_digits
+    def validate_digits(cls, value: str) -> str:
+        if not value.isdigit():
+            raise ValueError("Value must contain only digits.")
+        if cls.min_length is not None and len(value) < cls.min_length:
+            raise ValueError(
+                f"Value must have at least {cls.min_length} characters."
+            )
+        if cls.max_length is not None and len(value) > cls.max_length:
+            raise ValueError(
+                f"Value must have at most {cls.max_length} characters."
+            )
+        return value
+
+
+# Función para crear tipos personalizados
+def digits(min_length: Optional[int] = None, max_length: Optional[int] = None):
+    return Annotated[
+        str, Field(min_length=min_length, max_length=max_length), Digits
+    ]
 
 
 names_state = {

cuenca_validations/types/identities.py

@@ -2,8 +2,13 @@ import datetime as dt
 import re
 from typing import Any, Dict, List, Optional
 
-from pydantic import BaseModel, IPvAnyAddress
-from pydantic.class_validators import root_validator
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    IPvAnyAddress,
+    model_validator,
+)
 from pydantic.types import StrictStr
 
 from .enums import Country, KYCFileType, State, VerificationStatus
@@ -14,12 +19,34 @@ class PhoneNumber(StrictStr):
     max_length = 15
     regex = re.compile(r'^\+?[0-9]{10,14}$')
 
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, source_type: Any, handler: Any
+    ) -> Dict[str, Any]:
+        return {
+            'type': 'str',
+            'pattern': cls.regex.pattern,
+            'min_length': cls.min_length,
+            'max_length': cls.max_length,
+        }
+
 
 class CurpField(StrictStr):
     min_length = 18
     max_length = 18
     regex = re.compile(r'^[A-Z]{4}[0-9]{6}[A-Z]{6}[A-Z|0-9][0-9]$')
 
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, source_type: Any, handler: Any
+    ) -> Dict[str, Any]:
+        return {
+            'type': 'str',
+            'pattern': cls.regex.pattern,
+            'min_length': cls.min_length,
+            'max_length': cls.max_length,
+        }
+
 
 class Rfc(StrictStr):
     min_length = 12
@@ -42,9 +69,8 @@ class Address(BaseModel):
     country: Optional[Country] = None
     city: Optional[str] = None
     full_name: Optional[str] = None
-
-    class Config:
-        schema_extra = {
+    model_config = ConfigDict(
+        json_schema_extra={
             "example": {
                 "street": "Reforma",
                 "ext_number": "265",
@@ -56,8 +82,10 @@ class Address(BaseModel):
                 "city": "Cuauhtémoc",
             }
         }
+    )
 
-    @root_validator()
+    @model_validator(mode='before')
+    @classmethod
     def full_name_complete(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         if values.get('full_name'):
             return values
@@ -74,9 +102,8 @@ class Beneficiary(BaseModel):
     phone_number: PhoneNumber
     user_relationship: str
     percentage: int
-
-    class Config:
-        schema_extra = {
+    model_config = ConfigDict(
+        json_schema_extra={
             "example": {
                 "name": "Juan Perez",
                 "birth_date": "1907-07-06",
@@ -85,74 +112,58 @@ class Beneficiary(BaseModel):
                 "percentage": 100,
             }
         }
+    )
 
 
 class VerificationErrors(BaseModel):
-    identifier: str
-    error: str
-    code: str
-    message: Optional[str]
-
-    class Config:
-        fields = {
-            'identifier': {
-                'description': 'Unique identifier for the step validation'
-            },
-            'error': {
-                'description': 'Error throwed on validation,'
-                ' can be StepError or SystemError in case of '
-                'KYCProvider intermittence'
-            },
-            'code': {
-                'description': 'Specific code of the failure in the step.'
-            },
-            'message': {'description': 'Error description'},
-        }
-
-        schema_extra = {
+    identifier: str = Field(
+        ..., description='Unique identifier for the step validation'
+    )
+    error: str = Field(
+        ...,
+        description='Error throwed on validation,'
+        ' can be StepError or SystemError in case of '
+        'KYCProvider intermittence',
+    )
+    code: str = Field(
+        ..., description='Specific code of the failure in the step.'
+    )
+    message: Optional[str] = Field(None, description='Error description')
+    model_config = ConfigDict(
+        json_schema_extra={
             "example": {
                 "identifier": "age-check",
                 "error": 'StepError',
                 "code": "underage.noDOB",
                 "message": "The date of birth could not be obtained",
             }
-        }
+        },
+    )
 
 
 class KYCFile(BaseModel):
     type: KYCFileType
-    uri_front: str
-    uri_back: Optional[str] = None
+    uri_front: str = Field(..., description='API uri to fetch the file')
+    uri_back: Optional[str] = Field(
+        None, description='API uri to fetch the file'
+    )
     is_mx: bool = True
     data: Optional[dict] = None
-    status: Optional[VerificationStatus] = None
-    errors: Optional[List[VerificationErrors]]
-    verification_id: Optional[str]
-    attempt: Optional[int]
-
-    class Config:
-        fields = {
-            'uri_front': {'description': 'API uri to fetch the file'},
-            'uri_back': {'description': 'API uri to fetch the file'},
-            'status': {
-                'description': 'The status of the file depends '
-                'on KYCValidation'
-            },
-            'errors': {
-                'description': 'List of document errors found '
-                'during kyc validation'
-            },
-            'attempt': {
-                'description': 'The number of kyc_validation '
-                'intents for this docuemnt'
-            },
-            'verification_id': {
-                'description': 'The provider identifier of the '
-                'validation result'
-            },
-        }
-
-        schema_extra = {
+    status: Optional[VerificationStatus] = Field(
+        None, description='The status of the file depends on KYCValidation'
+    )
+    errors: Optional[List[VerificationErrors]] = Field(
+        None, description='List of document errors found during kyc validation'
+    )
+    verification_id: Optional[str] = Field(
+        None, description='The provider identifier of the validation result'
+    )
+    attempt: Optional[int] = Field(
+        None,
+        description='The number of kyc_validation intents for this document',
+    )
+    model_config = ConfigDict(
+        json_schema_extra={
             "example": {
                 "type": "ine",
                 "is_mx": True,
@@ -162,19 +173,20 @@ class KYCFile(BaseModel):
                 "status": "created",
                 "errors": [],
             }
-        }
+        },
+    )
 
 
 class TOSAgreement(BaseModel):
     version: str
     ip: IPvAnyAddress
-    location: Optional[str]
-
-    class Config:
-        schema_extra = {
+    location: Optional[str] = None
+    model_config = ConfigDict(
+        json_schema_extra={
             "example": {
                 "version": "2022-01-01",
                 "ip": "192.168.0.1",
                 "location": "19.427224, -99.168082",
             }
         }
+    )

cuenca_validations/types/morals.py

@@ -49,6 +49,8 @@ class VulnerableActivityDetails(BaseModel):
 
 
 class PhysicalPerson(BaseModel):
+    model_config = dict(arbitrary_types_allowed=True)
+
     names: str
     first_surname: str
     second_surname: Optional[str] = None

cuenca_validations/types/queries.py

@@ -1,8 +1,14 @@
 import datetime as dt
 from typing import Optional
 
-from pydantic import BaseModel, EmailStr, Extra, validator
-from pydantic.types import ConstrainedInt, PositiveInt
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    EmailStr,
+    PositiveInt,
+    conint,
+    field_validator,
+)
 
 from ..typing import DictStrAny
 from ..validators import sanitize_dict
@@ -23,14 +29,11 @@ from .identities import CurpField
 MAX_PAGE_SIZE = 100
 
 
-class PageSize(ConstrainedInt):
-    gt = 0
-    le = MAX_PAGE_SIZE
-
-
 class QueryParams(BaseModel):
     count: bool = False
-    page_size: PageSize = PageSize(MAX_PAGE_SIZE)
+    page_size: conint(  # type: ignore[valid-type]
+        gt=0, le=MAX_PAGE_SIZE
+    ) = MAX_PAGE_SIZE  # Add default value
     limit: Optional[PositiveInt] = None
     user_id: Optional[str] = None
     created_before: Optional[dt.datetime] = None
@@ -38,9 +41,9 @@ class QueryParams(BaseModel):
     related_transaction: Optional[str] = None
     platform_id: Optional[str] = None
 
-    class Config:
-        extra = Extra.forbid  # raise ValidationError if there are extra fields
-        fields = {
+    model_config = ConfigDict(
+        extra="forbid",
+        json_schema_extra={
             'count': {'description': 'Set `true` value to get only a counter'},
             'page_size': {'description': 'Number of items per page'},
             'limit': {'description': 'Limit of items to query'},
@@ -54,7 +57,8 @@ class QueryParams(BaseModel):
                 'or greater than this value, this field represents the min '
                 'creation date.'
             },
-        }
+        },
+    )
 
     def dict(self, *args, **kwargs) -> DictStrAny:
         kwargs.setdefault('exclude_none', True)
@@ -93,14 +97,32 @@ class CardTransactionQuery(TransactionQuery):
 class ApiKeyQuery(QueryParams):
     active: Optional[bool] = None
 
-    class Config(QueryParams.Config):
-        fields = {
-            **QueryParams.Config.fields,
-            'active': {
-                'description': 'Set `true` value to fetch active keys or '
-                '`false` to fetch deactivated keys'
-            },
-        }
+    model_config = ConfigDict(
+        extra="forbid",
+        json_schema_extra={
+            'properties': {
+                'active': {
+                    'description': 'Set `true` value to fetch active keys or '
+                    '`false` to fetch deactivated keys'
+                },
+                'count': {
+                    'description': 'Set `true` value to get only a counter'
+                },
+                'page_size': {'description': 'Number of items per page'},
+                'limit': {'description': 'Limit of items to query'},
+                'created_before': {
+                    'description': 'Filtered items have a `created_at` '
+                    'date equal or lower than this value, this field '
+                    'represents the max creation date.'
+                },
+                'created_after': {
+                    'description': 'Filtered items have a `created_at` '
+                    'date equal or greater than this value, this field '
+                    'represents the min creation date.'
+                },
+            }
+        },
+    )
 
 
 class CardQuery(QueryParams):
@@ -116,10 +138,15 @@ class CardQuery(QueryParams):
     status: Optional[CardStatus] = None
     type: Optional[CardType] = None
 
-    @validator('exp_month', 'exp_year', 'cvv2', 'cvv')
-    def query_by_exp_cvv_if_number_set(cls, v, values):
-        if not values['number']:
-            raise ValueError('Number must be set to query by exp or cvv')
+    @field_validator('exp_month', 'exp_year', 'cvv2', 'cvv')
+    def query_by_exp_cvv_if_number_set(cls, v, info):
+        if not info.data.get('number'):
+            raise ValueError(
+                '''
+                exp_month, exp_year, cvv and cvv2 can
+                only be set when number is provided
+                '''
+            )
         return v
 
 
@@ -127,9 +154,9 @@ class StatementQuery(QueryParams):
     year: int
     month: int
 
-    @validator('month')
-    def validate_year_month(cls, month, values):
-        year = values['year']
+    @field_validator('month')
+    def validate_year_month(cls, month, info):
+        year = info.data['year']
         month_now = dt.date.today().replace(day=1)
         month_set = dt.date(year, month, 1)
         if month_set >= month_now:
@@ -163,6 +190,8 @@ class UserQuery(QueryParams):
 
 
 class IdentityQuery(QueryParams):
+    model_config = dict(arbitrary_types_allowed=True)
+
     curp: Optional[CurpField] = None
     rfc: Optional[str] = None
     status: Optional[UserStatus] = None