🐛 fix single quote issue (#148)

* 🐛 fix single quote issue

* ♻️ fix all single quotes issue

Author: yezz123

pydantic_extra_types/__init__.py

@@ -1 +1 @@
-__version__ = "2.5.0"
+__version__ = '2.5.0'

pydantic_extra_types/color.py

@@ -121,11 +121,11 @@ def _parse_str(cls, value: Any, handler: core_schema.ValidatorFunctionWrapHandle
         if not isinstance(value, str):
             return value
         try:
-            value = tuple(float(x) for x in value.split(","))
+            value = tuple(float(x) for x in value.split(','))
         except ValueError:
             raise PydanticCustomError(
-                "coordinate_error",
-                "value is not a valid coordinate: string is not recognized as a valid coordinate",
+                'coordinate_error',
+                'value is not a valid coordinate: string is not recognized as a valid coordinate',
             )
         return ArgsKwargs(args=value)
 
@@ -136,7 +136,7 @@ def _parse_tuple(cls, value: Any, handler: core_schema.ValidatorFunctionWrapHand
         return ArgsKwargs(args=handler(value))
 
     def __str__(self) -> str:
-        return f"{self.latitude},{self.longitude}"
+        return f'{self.latitude},{self.longitude}'
 
     def __eq__(self, other: Any) -> bool:
         return isinstance(other, Coordinate) and self.latitude == other.latitude and self.longitude == other.longitude

pydantic_extra_types/coordinate.py

@@ -80,7 +80,7 @@ class Product(BaseModel):
     @classmethod
     def _validate(cls, __input_value: str, _: core_schema.ValidationInfo) -> CountryAlpha2:
         if __input_value not in _index_by_alpha2():
-            raise PydanticCustomError("country_alpha2", "Invalid country alpha2 code")
+            raise PydanticCustomError('country_alpha2', 'Invalid country alpha2 code')
         return cls(__input_value)
 
     @classmethod
@@ -97,7 +97,7 @@ def __get_pydantic_json_schema__(
         cls, schema: core_schema.CoreSchema, handler: GetJsonSchemaHandler
     ) -> dict[str, Any]:
         json_schema = handler(schema)
-        json_schema.update({"pattern": r"^\w{2}$"})
+        json_schema.update({'pattern': r'^\w{2}$'})
         return json_schema
 
     @property
@@ -137,7 +137,7 @@ class Product(BaseModel):
     @classmethod
     def _validate(cls, __input_value: str, _: core_schema.ValidationInfo) -> CountryAlpha3:
         if __input_value not in _index_by_alpha3():
-            raise PydanticCustomError("country_alpha3", "Invalid country alpha3 code")
+            raise PydanticCustomError('country_alpha3', 'Invalid country alpha3 code')
         return cls(__input_value)
 
     @classmethod
@@ -155,7 +155,7 @@ def __get_pydantic_json_schema__(
         cls, schema: core_schema.CoreSchema, handler: GetJsonSchemaHandler
     ) -> dict[str, Any]:
         json_schema = handler(schema)
-        json_schema.update({"pattern": r"^\w{3}$"})
+        json_schema.update({'pattern': r'^\w{3}$'})
         return json_schema
 
     @property
@@ -195,7 +195,7 @@ class Product(BaseModel):
     @classmethod
     def _validate(cls, __input_value: str, _: core_schema.ValidationInfo) -> CountryNumericCode:
         if __input_value not in _index_by_numeric_code():
-            raise PydanticCustomError("country_numeric_code", "Invalid country numeric code")
+            raise PydanticCustomError('country_numeric_code', 'Invalid country numeric code')
         return cls(__input_value)
 
     @classmethod
@@ -213,7 +213,7 @@ def __get_pydantic_json_schema__(
         cls, schema: core_schema.CoreSchema, handler: GetJsonSchemaHandler
     ) -> dict[str, Any]:
         json_schema = handler(schema)
-        json_schema.update({"pattern": r"^[0-9]{3}$"})
+        json_schema.update({'pattern': r'^[0-9]{3}$'})
         return json_schema
 
     @property
@@ -252,7 +252,7 @@ class Product(BaseModel):
     @classmethod
     def _validate(cls, __input_value: str, _: core_schema.ValidationInfo) -> CountryShortName:
         if __input_value not in _index_by_short_name():
-            raise PydanticCustomError("country_short_name", "Invalid country short name")
+            raise PydanticCustomError('country_short_name', 'Invalid country short name')
         return cls(__input_value)
 
     @classmethod

pydantic_extra_types/country.py

@@ -18,17 +18,17 @@
 
 # List of codes that should not be usually used within regular transactions
 _CODES_FOR_BONDS_METAL_TESTING = {
-    "XTS",  # testing
-    "XAU",  # gold
-    "XAG",  # silver
-    "XPD",  # palladium
-    "XPT",  # platinum
-    "XBA",  # Bond Markets Unit European Composite Unit (EURCO)
-    "XBB",  # Bond Markets Unit European Monetary Unit (E.M.U.-6)
-    "XBC",  # Bond Markets Unit European Unit of Account 9 (E.U.A.-9)
-    "XBD",  # Bond Markets Unit European Unit of Account 17 (E.U.A.-17)
-    "XXX",  # no currency
-    "XDR",  # SDR (Special Drawing Right)
+    'XTS',  # testing
+    'XAU',  # gold
+    'XAG',  # silver
+    'XPD',  # palladium
+    'XPT',  # platinum
+    'XBA',  # Bond Markets Unit European Composite Unit (EURCO)
+    'XBB',  # Bond Markets Unit European Monetary Unit (E.M.U.-6)
+    'XBC',  # Bond Markets Unit European Unit of Account 9 (E.U.A.-9)
+    'XBD',  # Bond Markets Unit European Unit of Account 17 (E.U.A.-17)
+    'XXX',  # no currency
+    'XDR',  # SDR (Special Drawing Right)
 }
 
 
@@ -69,7 +69,7 @@ def _validate(cls, currency_code: str, _: core_schema.ValidationInfo) -> str:
         """
         if currency_code not in cls.allowed_currencies:
             raise PydanticCustomError(
-                "ISO4217", "Invalid ISO 4217 currency code. See https://en.wikipedia.org/wiki/ISO_4217"
+                'ISO4217', 'Invalid ISO 4217 currency code. See https://en.wikipedia.org/wiki/ISO_4217'
             )
         return currency_code
 
@@ -85,7 +85,7 @@ def __get_pydantic_json_schema__(
         cls, schema: core_schema.CoreSchema, handler: GetJsonSchemaHandler
     ) -> dict[str, Any]:
         json_schema = handler(schema)
-        json_schema.update({"enum": cls.allowed_countries_list})
+        json_schema.update({'enum': cls.allowed_countries_list})
         return json_schema
 
 
@@ -129,10 +129,10 @@ def _validate(cls, currency_symbol: str, _: core_schema.ValidationInfo) -> str:
         """
         if currency_symbol not in cls.allowed_currencies:
             raise PydanticCustomError(
-                "InvalidCurrency",
-                "Invalid currency code."
-                " See https://en.wikipedia.org/wiki/ISO_4217. "
-                "Bonds, testing and precious metals codes are not allowed.",
+                'InvalidCurrency',
+                'Invalid currency code.'
+                ' See https://en.wikipedia.org/wiki/ISO_4217. '
+                'Bonds, testing and precious metals codes are not allowed.',
             )
         return currency_symbol
 
@@ -175,5 +175,5 @@ def __get_pydantic_json_schema__(
 
         """
         json_schema = handler(schema)
-        json_schema.update({"enum": cls.allowed_countries_list})
+        json_schema.update({'enum': cls.allowed_countries_list})
         return json_schema

pydantic_extra_types/currency_code.py

@@ -25,7 +25,7 @@ def isbn10_digit_calc(isbn: str) -> str:
 
     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)
+            valid_check_digit = 'X' if check_digit == 10 else str(check_digit)
 
     return valid_check_digit
 
@@ -115,23 +115,23 @@ def validate_isbn_format(value: str) -> None:
         isbn_length = len(value)
 
         if isbn_length not in (10, 13):
-            raise PydanticCustomError("isbn_length", f"Length for ISBN must be 10 or 13 digits, not {isbn_length}")
+            raise PydanticCustomError('isbn_length', f'Length for ISBN must be 10 or 13 digits, not {isbn_length}')
 
         if isbn_length == 10:
-            if not value[:-1].isdigit() or ((value[-1] != "X") and (not value[-1].isdigit())):
-                raise PydanticCustomError("isbn10_invalid_characters", "First 9 digits of ISBN-10 must be integers")
+            if not value[:-1].isdigit() or ((value[-1] != 'X') and (not value[-1].isdigit())):
+                raise PydanticCustomError('isbn10_invalid_characters', 'First 9 digits of ISBN-10 must be integers')
             if isbn10_digit_calc(value) != value[-1]:
-                raise PydanticCustomError("isbn_invalid_digit_check_isbn10", "Provided digit is invalid for given ISBN")
+                raise PydanticCustomError('isbn_invalid_digit_check_isbn10', 'Provided digit is invalid for given ISBN')
 
         if isbn_length == 13:
             if not value.isdigit():
-                raise PydanticCustomError("isbn13_invalid_characters", "All digits of ISBN-13 must be integers")
-            if value[:3] not in ("978", "979"):
+                raise PydanticCustomError('isbn13_invalid_characters', 'All digits of ISBN-13 must be integers')
+            if value[:3] not in ('978', '979'):
                 raise PydanticCustomError(
-                    "isbn_invalid_early_characters", "The first 3 digits of ISBN-13 must be 978 or 979"
+                    'isbn_invalid_early_characters', 'The first 3 digits of ISBN-13 must be 978 or 979'
                 )
             if isbn13_digit_calc(value) != value[-1]:
-                raise PydanticCustomError("isbn_invalid_digit_check_isbn13", "Provided digit is invalid for given ISBN")
+                raise PydanticCustomError('isbn_invalid_digit_check_isbn13', 'Provided digit is invalid for given ISBN')
 
     @staticmethod
     def convert_isbn10_to_isbn13(value: str) -> str:
@@ -145,8 +145,8 @@ def convert_isbn10_to_isbn13(value: str) -> str:
         """
 
         if len(value) == 10:
-            base_isbn = f"978{value[:-1]}"
+            base_isbn = f'978{value[:-1]}'
             isbn13_digit = isbn13_digit_calc(base_isbn)
-            return ISBN(f"{base_isbn}{isbn13_digit}")
+            return ISBN(f'{base_isbn}{isbn13_digit}')
 
         return ISBN(value)

pydantic_extra_types/isbn.py

@@ -55,7 +55,7 @@ def _validate(cls, __input_value: str, _: core_schema.ValidationInfo) -> ISO639_
         """
         if __input_value not in cls.allowed_values:
             raise PydanticCustomError(
-                "ISO649_3", "Invalid ISO 639-3 language code. See https://en.wikipedia.org/wiki/ISO_639-3"
+                'ISO649_3', 'Invalid ISO 639-3 language code. See https://en.wikipedia.org/wiki/ISO_639-3'
             )
         return cls(__input_value)
 
@@ -95,7 +95,7 @@ def __get_pydantic_json_schema__(
 
         """
         json_schema = handler(schema)
-        json_schema.update({"enum": cls.allowed_values_list})
+        json_schema.update({'enum': cls.allowed_values_list})
         return json_schema
 
 
@@ -138,7 +138,7 @@ def _validate(cls, __input_value: str, _: core_schema.ValidationInfo) -> ISO639_
         """
         if __input_value not in cls.allowed_values:
             raise PydanticCustomError(
-                "ISO649_5", "Invalid ISO 639-5 language code. See https://en.wikipedia.org/wiki/ISO_639-5"
+                'ISO649_5', 'Invalid ISO 639-5 language code. See https://en.wikipedia.org/wiki/ISO_639-5'
             )
         return cls(__input_value)
 
@@ -178,5 +178,5 @@ def __get_pydantic_json_schema__(
 
         """
         json_schema = handler(schema)
-        json_schema.update({"enum": cls.allowed_values_list})
+        json_schema.update({'enum': cls.allowed_values_list})
         return json_schema

pydantic_extra_types/language_code.py

@@ -70,22 +70,22 @@ def validate_mac_address(value: bytes) -> str:
         """
         if len(value) < 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_len',
+                'Length for a {mac_address} MAC address must be {required_length}',
+                {'mac_address': value.decode(), 'required_length': 14},
             )
 
-        if value[2] in [ord(":"), ord("-")]:
+        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"
+                    '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_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
@@ -95,17 +95,17 @@ def validate_mac_address(value: bytes) -> str:
                     mac_address[i] = byte_value
                     x += 3
                 except ValueError as e:
-                    raise PydanticCustomError("mac_address_format", "Unrecognized format") from e
+                    raise PydanticCustomError('mac_address_format', 'Unrecognized format') from e
 
-        elif value[4] == ord("."):
+        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")
+                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_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
@@ -117,9 +117,9 @@ def validate_mac_address(value: bytes) -> str:
                     mac_address[i + 1] = byte_value
                     x += 5
                 except ValueError as e:
-                    raise PydanticCustomError("mac_address_format", "Unrecognized format") from e
+                    raise PydanticCustomError('mac_address_format', 'Unrecognized format') from e
 
         else:
-            raise PydanticCustomError("mac_address_format", "Unrecognized format")
+            raise PydanticCustomError('mac_address_format', 'Unrecognized format')
 
-        return ":".join(f"{b:02x}" for b in mac_address)
+        return ':'.join(f'{b:02x}' for b in mac_address)