cuenca-validations 0.11.33__tar.gz → 2.0.0.dev1__tar.gz

{cuenca_validations-0.11.33 → cuenca_validations-2.0.0.dev1}/PKG-INFO

@@ -1,21 +1,19 @@
 Metadata-Version: 2.1
 Name: cuenca_validations
-Version: 0.11.33
+Version: 2.0.0.dev1
 Summary: Cuenca common validations
 Home-page: https://github.com/cuenca-mx/cuenca-validations
 Author: Cuenca
 Author-email: dev@cuenca.com
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: clabe<1.3,>=1.2
-Requires-Dist: pydantic[email]<2.0,>=1.10
+Requires-Dist: clabe>=2.0.0
+Requires-Dist: pydantic[email]>=2.0
 Requires-Dist: dataclasses>=0.6; python_version < "3.7"
 Requires-Dist: python-dateutil>=2.7.0
 

{cuenca_validations-0.11.33 → cuenca_validations-2.0.0.dev1}/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-0.11.33 → cuenca_validations-2.0.0.dev1}/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-2.0.0.dev1/cuenca_validations/types/card.py

@@ -0,0 +1,26 @@
+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
+
+
+class StrictPaymentCardNumber(BaseModel):
+
+    card_number: PaymentCardNumber
+
+    @field_validator('card_number')
+    def validate_bin(cls, card_number: PaymentCardNumber) -> PaymentCardNumber:
+        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-0.11.33 → cuenca_validations-2.0.0.dev1}/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-2.0.0.dev1/cuenca_validations/types/general.py

@@ -0,0 +1,119 @@
+import json
+from typing import Generator, Optional
+
+from pydantic import BeforeValidator, Field
+from typing_extensions import Annotated
+
+from ..validators import sanitize_dict, sanitize_item
+from .enums import State
+
+
+class SantizedDict(dict):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        sanitize_dict(self)
+
+
+class JSONEncoder(json.JSONEncoder):
+    def default(self, o):
+        return sanitize_item(o, default=super().default)
+
+
+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
+
+
+StrictPositiveInt = Annotated[
+    int, BeforeValidator(validate_strict_positive_int)
+]
+
+
+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
+
+
+StrictPositiveFloat = Annotated[
+    float, BeforeValidator(validate_strict_positive_float)
+]
+
+
+# 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
+
+    @classmethod
+    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 = {
+    State.NE: 'Nacido en el Extranjero',
+    State.AS: 'Aguascalientes',
+    State.BC: 'Baja California',
+    State.BS: 'Baja California Sur',
+    State.CC: 'Campeche',
+    State.CS: 'Chiapas',
+    State.CH: 'Chihuahua',
+    State.CL: 'Coahuila',
+    State.CM: 'Colima',
+    State.DF: 'Ciudad de México',
+    State.DG: 'Durango',
+    State.GT: 'Guanajuato',
+    State.GR: 'Guerrero',
+    State.HG: 'Hidalgo',
+    State.JC: 'Jalisco',
+    State.MC: 'México',
+    State.MN: 'Michoacan',
+    State.MS: 'Morelos',
+    State.NT: 'Nayarit',
+    State.NL: 'Nuevo León',
+    State.OC: 'Oaxaca',
+    State.PL: 'Puebla',
+    State.QT: 'Querétaro',
+    State.QR: 'Quintana Roo',
+    State.SP: 'San Luis Potosí',
+    State.SL: 'Sinaloa',
+    State.SR: 'Sonora',
+    State.TC: 'Tabasco',
+    State.TL: 'Tlaxcala',
+    State.TS: 'Tamaulipas',
+    State.VZ: 'Veracruz',
+    State.YN: 'Yucatán',
+    State.ZS: 'Zacatecas',
+}
+
+
+def get_state_name(state: State):
+    return names_state[state]

{cuenca_validations-0.11.33 → cuenca_validations-2.0.0.dev1}/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-0.11.33 → cuenca_validations-2.0.0.dev1}/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-0.11.33 → cuenca_validations-2.0.0.dev1}/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