Merge branch 'main' into main

Author: yezz123

.github/dependabot.yml

@@ -9,7 +9,7 @@ updates:
     commit-message:
       prefix: ⬆
   # Python
-  - package-ecosystem: "pip"
+  - package-ecosystem: "uv"
     directory: "/"
     schedule:
       interval: "monthly"

.github/workflows/ci.yml

@@ -19,7 +19,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - uses: astral-sh/setup-uv@v5
+      - uses: astral-sh/setup-uv@v6
         with:
           enable-cache: true
 
@@ -47,7 +47,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - uses: astral-sh/setup-uv@v5
+      - uses: astral-sh/setup-uv@v6
         with:
           enable-cache: true
 
@@ -74,7 +74,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - uses: astral-sh/setup-uv@v5
+      - uses: astral-sh/setup-uv@v6
         with:
           enable-cache: true
 
@@ -111,7 +111,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - uses: astral-sh/setup-uv@v5
+      - uses: astral-sh/setup-uv@v6
         with:
           enable-cache: true
 

Makefile

@@ -7,9 +7,9 @@ sources = pydantic_extra_types tests
 
 .PHONY: install  ## Install the package, dependencies, and pre-commit for local development
 install: .uv
-	uv sync --frozen --group all --all-extras
+	uv sync --frozen --all-groups --all-extras
 	uv pip install pre-commit
-	pre-commit install --install-hooks
+	uv run pre-commit install --install-hooks
 
 .PHONY: rebuild-lockfiles  ## Rebuild lockfiles from scratch, updating all dependencies
 rebuild-lockfiles: .uv

pydantic_extra_types/__init__.py

@@ -1 +1 @@
-__version__ = '2.10.2'
+__version__ = '2.10.5'

pydantic_extra_types/color.py

@@ -354,7 +354,7 @@ def parse_color_value(value: int | str, max_val: int = 255) -> float:
     """
     try:
         color = float(value)
-    except ValueError as e:
+    except (ValueError, TypeError) as e:
         raise PydanticCustomError(
             'color_error',
             'value is not a valid color: color values must be a valid number',

pydantic_extra_types/coordinate.py

@@ -6,17 +6,25 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, ClassVar, Tuple
+from decimal import Decimal
+from typing import Any, ClassVar, Tuple, Union
 
 from pydantic import GetCoreSchemaHandler
 from pydantic._internal import _repr
 from pydantic_core import ArgsKwargs, PydanticCustomError, core_schema
 
+LatitudeType = Union[float, Decimal]
+LongitudeType = Union[float, Decimal]
+CoordinateType = Tuple[LatitudeType, LongitudeType]
+
 
 class Latitude(float):
     """Latitude value should be between -90 and 90, inclusive.
 
+    Supports both float and Decimal types.
+
     ```py
+    from decimal import Decimal
     from pydantic import BaseModel
     from pydantic_extra_types.coordinate import Latitude
 
@@ -25,9 +33,10 @@ class Location(BaseModel):
         latitude: Latitude
 
 
-    location = Location(latitude=41.40338)
-    print(location)
-    # > latitude=41.40338
+    # Using float
+    location1 = Location(latitude=41.40338)
+    # Using Decimal
+    location2 = Location(latitude=Decimal('41.40338'))
     ```
     """
 
@@ -36,13 +45,21 @@ class Location(BaseModel):
 
     @classmethod
     def __get_pydantic_core_schema__(cls, source: type[Any], handler: GetCoreSchemaHandler) -> core_schema.CoreSchema:
-        return core_schema.float_schema(ge=cls.min, le=cls.max)
+        return core_schema.union_schema(
+            [
+                core_schema.float_schema(ge=cls.min, le=cls.max),
+                core_schema.decimal_schema(ge=Decimal(cls.min), le=Decimal(cls.max)),
+            ]
+        )
 
 
 class Longitude(float):
     """Longitude value should be between -180 and 180, inclusive.
 
+    Supports both float and Decimal types.
+
     ```py
+    from decimal import Decimal
     from pydantic import BaseModel
 
     from pydantic_extra_types.coordinate import Longitude
@@ -52,9 +69,10 @@ class Location(BaseModel):
         longitude: Longitude
 
 
-    location = Location(longitude=2.17403)
-    print(location)
-    # > longitude=2.17403
+    # Using float
+    location1 = Location(longitude=2.17403)
+    # Using Decimal
+    location2 = Location(longitude=Decimal('2.17403'))
     ```
     """
 
@@ -63,7 +81,12 @@ class Location(BaseModel):
 
     @classmethod
     def __get_pydantic_core_schema__(cls, source: type[Any], handler: GetCoreSchemaHandler) -> core_schema.CoreSchema:
-        return core_schema.float_schema(ge=cls.min, le=cls.max)
+        return core_schema.union_schema(
+            [
+                core_schema.float_schema(ge=cls.min, le=cls.max),
+                core_schema.decimal_schema(ge=Decimal(cls.min), le=Decimal(cls.max)),
+            ]
+        )
 
 
 @dataclass
@@ -73,10 +96,11 @@ class Coordinate(_repr.Representation):
     You can use the `Coordinate` data type for storing coordinates. Coordinates can be
     defined using one of the following formats:
 
-    1. Tuple: `(Latitude, Longitude)`. For example: `(41.40338, 2.17403)`.
+    1. Tuple: `(Latitude, Longitude)`. For example: `(41.40338, 2.17403)` or `(Decimal('41.40338'), Decimal('2.17403'))`.
     2. `Coordinate` instance: `Coordinate(latitude=Latitude, longitude=Longitude)`.
 
     ```py
+    from decimal import Decimal
     from pydantic import BaseModel
 
     from pydantic_extra_types.coordinate import Coordinate
@@ -86,7 +110,12 @@ class Location(BaseModel):
         coordinate: Coordinate
 
 
-    location = Location(coordinate=(41.40338, 2.17403))
+    # Using float values
+    location1 = Location(coordinate=(41.40338, 2.17403))
+    # > coordinate=Coordinate(latitude=41.40338, longitude=2.17403)
+
+    # Using Decimal values
+    location2 = Location(coordinate=(Decimal('41.40338'), Decimal('2.17403')))
     # > coordinate=Coordinate(latitude=41.40338, longitude=2.17403)
     ```
     """
@@ -102,7 +131,7 @@ def __get_pydantic_core_schema__(cls, source: type[Any], handler: GetCoreSchemaH
             core_schema.no_info_wrap_validator_function(cls._parse_str, core_schema.str_schema()),
             core_schema.no_info_wrap_validator_function(
                 cls._parse_tuple,
-                handler.generate_schema(Tuple[float, float]),
+                handler.generate_schema(CoordinateType),
             ),
             handler(source),
         ]

pydantic_extra_types/domain.py

@@ -14,6 +14,10 @@
 class DomainStr(str):
     """A string subclass with custom validation for domain string format."""
 
+    _domain_re_pattern = (
+        r'(?=^.{1,253}$)' r'(^((?!-)[a-zA-Z0-9-]{1,63}(?<!-)\.)+' r'([a-zA-Z]{2,63}|xn--[a-zA-Z0-9]{2,59})$)'
+    )
+
     @classmethod
     def validate(cls, __input_value: Any, _: Any) -> str:
         """Validate a domain name from the provided value.
@@ -37,8 +41,7 @@ def _validate(cls, v: Any) -> DomainStr:
         if len(v) < 1 or len(v) > 253:
             raise PydanticCustomError('domain_length', 'Domain must be between 1 and 253 characters')
 
-        pattern = r'^([a-z0-9-]+(\.[a-z0-9-]+)+)$'
-        if not re.match(pattern, v):
+        if not re.match(cls._domain_re_pattern, v):
             raise PydanticCustomError('domain_format', 'Invalid domain format')
 
         return cls(v)

pydantic_extra_types/isbn.py

@@ -5,6 +5,7 @@
 
 from __future__ import annotations
 
+import itertools as it
 from typing import Any
 
 from pydantic import GetCoreSchemaHandler
@@ -21,11 +22,8 @@ def isbn10_digit_calc(isbn: str) -> str:
         The calculated last digit of the ISBN-10 value.
     """
     total = sum(int(digit) * (10 - idx) for idx, digit in enumerate(isbn[:9]))
-
-    for check_digit in range(1, 11):
-        if (total + check_digit) % 11 == 0:
-            valid_check_digit = 'X' if check_digit == 10 else str(check_digit)
-
+    diff = (11 - total) % 11
+    valid_check_digit = 'X' if diff == 10 else str(diff)
     return valid_check_digit
 
 
@@ -38,9 +36,9 @@ def isbn13_digit_calc(isbn: str) -> str:
     Returns:
         The calculated last digit of the ISBN-13 value.
     """
-    total = sum(int(digit) * (1 if idx % 2 == 0 else 3) for idx, digit in enumerate(isbn[:12]))
+    total = sum(int(digit) * factor for digit, factor in zip(isbn[:12], it.cycle((1, 3))))
 
-    check_digit = (10 - (total % 10)) % 10
+    check_digit = (10 - total) % 10
 
     return str(check_digit)
 

pydantic_extra_types/mac_address.py

@@ -63,58 +63,36 @@ def _validate(cls, __input_value: str, _: Any) -> str:
     @staticmethod
     def validate_mac_address(value: bytes) -> str:
         """Validate a MAC Address from the provided byte value."""
-        if len(value) < 14:
+        string = value.decode()
+        if len(string) < 14:
             raise PydanticCustomError(
                 'mac_address_len',
                 'Length for a {mac_address} MAC address must be {required_length}',
-                {'mac_address': value.decode(), 'required_length': 14},
+                {'mac_address': string, 'required_length': 14},
             )
-
-        if value[2] in [ord(':'), ord('-')]:
-            if (len(value) + 1) % 3 != 0:
-                raise PydanticCustomError(
-                    'mac_address_format', 'Must have the format xx:xx:xx:xx:xx:xx or xx-xx-xx-xx-xx-xx'
-                )
-            n = (len(value) + 1) // 3
-            if n not in (6, 8, 20):
-                raise PydanticCustomError(
-                    'mac_address_format',
-                    'Length for a {mac_address} MAC address must be {required_length}',
-                    {'mac_address': value.decode(), 'required_length': (6, 8, 20)},
-                )
-            mac_address = bytearray(n)
-            x = 0
-            for i in range(n):
-                try:
-                    byte_value = int(value[x : x + 2], 16)
-                    mac_address[i] = byte_value
-                    x += 3
-                except ValueError as e:
-                    raise PydanticCustomError('mac_address_format', 'Unrecognized format') from e
-
-        elif value[4] == ord('.'):
-            if (len(value) + 1) % 5 != 0:
-                raise PydanticCustomError('mac_address_format', 'Must have the format xx.xx.xx.xx.xx.xx')
-            n = 2 * (len(value) + 1) // 5
-            if n not in (6, 8, 20):
-                raise PydanticCustomError(
-                    'mac_address_format',
-                    'Length for a {mac_address} MAC address must be {required_length}',
-                    {'mac_address': value.decode(), 'required_length': (6, 8, 20)},
-                )
-            mac_address = bytearray(n)
-            x = 0
-            for i in range(0, n, 2):
-                try:
-                    byte_value = int(value[x : x + 2], 16)
-                    mac_address[i] = byte_value
-                    byte_value = int(value[x + 2 : x + 4], 16)
-                    mac_address[i + 1] = byte_value
-                    x += 5
-                except ValueError as e:
-                    raise PydanticCustomError('mac_address_format', 'Unrecognized format') from e
-
+        for sep, partbytes in ((':', 2), ('-', 2), ('.', 4)):
+            if sep in string:
+                parts = string.split(sep)
+                if any(len(part) != partbytes for part in parts):
+                    raise PydanticCustomError(
+                        'mac_address_format',
+                        f'Must have the format xx{sep}xx{sep}xx{sep}xx{sep}xx{sep}xx',
+                    )
+                if len(parts) * partbytes // 2 not in (6, 8, 20):
+                    raise PydanticCustomError(
+                        'mac_address_format',
+                        'Length for a {mac_address} MAC address must be {required_length}',
+                        {'mac_address': string, 'required_length': (6, 8, 20)},
+                    )
+                mac_address = []
+                for part in parts:
+                    for idx in range(0, partbytes, 2):
+                        try:
+                            byte_value = int(part[idx : idx + 2], 16)
+                        except ValueError as exc:
+                            raise PydanticCustomError('mac_address_format', 'Unrecognized format') from exc
+                        else:
+                            mac_address.append(byte_value)
+                return ':'.join(f'{b:02x}' for b in mac_address)
         else:
             raise PydanticCustomError('mac_address_format', 'Unrecognized format')
-
-        return ':'.join(f'{b:02x}' for b in mac_address)