Add prefix suffix contains email

Author: code-yeongyu

README.md

@@ -45,6 +45,36 @@ school = School(school_code="school_1", school_name="School 1")
 school = School(school_code="scho", school_name="School 1") # ValueError: 'scho' does not match regex pattern '^school.*$'
 ```
 
+- `PrefixStr`: Validate string attributes with a prefix.
+
+- `SuffixStr`: Validate string attributes with a suffix.
+
+- `ContainsStr`: Validate string attributes with a substring.
+
+- `EmailStr`: Validate string attributes with an email pattern.
+
+#### TBD
+
+- `NotContainsStr`: Validate string attributes with a not contains pattern.
+
+- `LengthStr`: Validate string attributes with a length pattern.
+
+- `NumericStr`: Validate string attributes with a numeric pattern.
+
+- `AlphabeticalStr`: Validate string attributes with an alphabetical pattern.
+
+- `AlphanumericStr`: Validate string attributes with an alphanumeric pattern.
+
+- `UrlStr`: Validate string attributes with a url pattern.
+
+- `PhoneStr`: Validate string attributes with a phone pattern.
+
+- `CreditCardStr`: Validate string attributes with a credit card pattern.
+
+- `LowercaseStr`: Validate string attributes with a lowercase pattern.
+
+- `UppercaseStr`: Validate string attributes with an uppercase pattern.
+
 ### Numeric
 
 - `RangeInt`: Set boundaries for integer attributes.
@@ -97,6 +127,18 @@ transaction = Transaction(amount=Decimal("0.005"), amount2=Decimal("5.0")) # Val
 transaction = Transaction(amount=Decimal("150.75"), amount2=Decimal("15")) # ValueError: 15 is not in range [1, 10]
 ```
 
+#### TBD
+
+- `Positive*`: Validate integer | float | Decimal attributes with a positive pattern.
+
+- `Negative*`: Validate integer | float | Decimal attributes with a negative pattern.
+
+- `Odd*`: Validate integer | float | Decimal attributes with an odd pattern.
+
+- `Even*`: Validate integer | float | Decimal attributes with an even pattern.
+
+- `Divisible*`: Validate integer | float | Decimal attributes with a divisible pattern.
+
 ### ETC
 
 ... More types will be added soon.

extended_type/__init__.py

@@ -1,8 +1,12 @@
+from .contains_str import ContainsStr as ContainsStr
+from .prefix_str import PrefixStr as PrefixStr
 from .pydantic_compatibility import PYDANTIC_AVAILABLE as _PYDANTIC_AVAILABLE
 from .range_decimal import RangeDecimal as RangeDecimal
 from .range_float import RangeFloat as RangeFloat
 from .range_int import RangeInt as RangeInt
+from .regex_str import EmailStr as EmailStr
 from .regex_str import RegexStr as RegexStr
+from .suffix_str import SuffixStr as SuffixStr
 from .type_extended import TypeExtended as TypeExtended
 from .type_extended import type_extended as type_extended
 

extended_type/contains_str.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import Any, Generic, TypeVar, cast
+
+from typing_extensions import get_args
+
+T = TypeVar("T", bound=str)
+
+
+class ContainsStrType(str, Generic[T]):
+    @staticmethod
+    def extract_substring(annotation: type[Any]) -> str:
+        # extracts ContainsStr[typing.Literal[SUBSTRING]], <class 'str'>
+        union_args = cast(tuple[str], get_args(annotation))
+
+        # extracts typing.Literal[SUBSTRING]
+        extended_str_args = get_args(union_args[0])
+
+        # extracts (SUBSTRING,)
+        literal_substring = get_args(extended_str_args[0])
+
+        # extracts SUBSTRING
+        substring = literal_substring[0]
+        return substring
+
+    @staticmethod
+    def validate(substring: str, value: str) -> str:
+        if substring not in value:
+            raise ValueError(f"`{value}` does not contain `{substring}`")
+        return value
+
+
+SUBSTRING = TypeVar("SUBSTRING", bound=str)
+ContainsStr = ContainsStrType[SUBSTRING] | str

extended_type/extended_type_validator.py

@@ -2,11 +2,14 @@
 
 from typing_extensions import get_args, get_origin
 
+from extended_type.contains_str import ContainsStrType
+from extended_type.prefix_str import PrefixStrType
 from extended_type.range_decimal import RangeDecimalType
 from extended_type.range_float import RangeFloatType
 from extended_type.range_int import RangeIntType
 from extended_type.range_numeric import NUMERIC_TYPE, RangeNumericBase
 from extended_type.regex_str import RegexStrType
+from extended_type.suffix_str import SuffixStrType
 
 
 class ExtendedTypeValidator:
@@ -18,6 +21,9 @@ def __init__(
     ):
         self.validators = validators or {
             RegexStrType: self._validate_regex_str,
+            PrefixStrType: self._validate_prefix_str,
+            SuffixStrType: self._validate_suffix_str,
+            ContainsStrType: self._validate_contains_str,
             RangeIntType: lambda value, annotation: self._validate_number(
                 cast(RangeNumericBase, RangeIntType), value, annotation
             ),
@@ -54,3 +60,19 @@ def _validate_number(
     def _validate_regex_str(self, value: str, annotation: type[str]):
         pattern = RegexStrType.extract_pattern(annotation)
         RegexStrType.validate(pattern, value)
+
+    def _validate_email_str(self, value: str, _annotation: type[str]):
+        EMAIL_PATTERN = "^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-.]+$"
+        RegexStrType.validate(EMAIL_PATTERN, value)
+
+    def _validate_prefix_str(self, value: str, annotation: type[str]):
+        prefix = PrefixStrType.extract_prefix(annotation)
+        PrefixStrType.validate(prefix, value)
+
+    def _validate_suffix_str(self, value: str, annotation: type[str]):
+        subfix = SuffixStrType.extract_suffix(annotation)
+        SuffixStrType.validate(subfix, value)
+
+    def _validate_contains_str(self, value: str, annotation: type[str]):
+        subset = ContainsStrType.extract_substring(annotation)
+        ContainsStrType.validate(subset, value)

extended_type/prefix_str.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import Any, Generic, TypeVar, cast
+
+from typing_extensions import get_args
+
+T = TypeVar("T", bound=str)
+
+
+class PrefixStrType(str, Generic[T]):
+    @staticmethod
+    def extract_prefix(annotation: type[Any]) -> str:
+        # extracts PrefixStr[typing.Literal[PREFIX]], <class 'str'>
+        union_args = cast(tuple[str], get_args(annotation))
+
+        # extracts typing.Literal[PREFIX]
+        extended_str_args = get_args(union_args[0])
+
+        # extracts (PREFIX,)
+        literal_prefix = get_args(extended_str_args[0])
+
+        # extracts PREFIX
+        prefix = literal_prefix[0]
+        return prefix
+
+    @staticmethod
+    def validate(prefix: str, value: str) -> str:
+        if not value.startswith(prefix):
+            raise ValueError(f"`{value}` does not start with `{prefix}`")
+        return value
+
+
+PREFIX = TypeVar("PREFIX", bound=str)
+PrefixStr = PrefixStrType[PREFIX] | str

extended_type/regex_str.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import re
-from typing import Any, Generic, TypeVar, cast
+from typing import Any, Generic, Literal, TypeVar, cast
 
 from typing_extensions import get_args
 
@@ -33,3 +33,8 @@ def validate(pattern: str, value: str) -> str:
 
 PATTERN = TypeVar("PATTERN", bound=str)
 RegexStr = RegexStrType[PATTERN] | str
+
+
+EmailStr = (
+    RegexStrType[Literal["^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-.]+$"]] | str
+)

extended_type/suffix_str.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import Any, Generic, TypeVar, cast
+
+from typing_extensions import get_args
+
+T = TypeVar("T", bound=str)
+
+
+class SuffixStrType(str, Generic[T]):
+    @staticmethod
+    def extract_suffix(annotation: type[Any]) -> str:
+        # extracts SuffixStr[typing.Literal[SUFFIX]], <class 'str'>
+        union_args = cast(tuple[str], get_args(annotation))
+
+        # extracts typing.Literal[SUFFIX]
+        extended_str_args = get_args(union_args[0])
+
+        # extracts (SUFFIX,)
+        literal_suffix = get_args(extended_str_args[0])
+
+        # extracts SUFFIX
+        suffix = literal_suffix[0]
+        return suffix
+
+    @staticmethod
+    def validate(suffix: str, value: str) -> str:
+        if not value.endswith(suffix):
+            raise ValueError(f"`{value}` does not end with `{suffix}`")
+        return value
+
+
+SUFFIX = TypeVar("SUFFIX", bound=str)
+SuffixStr = SuffixStrType[SUFFIX] | str

extended_type/utils.py

@@ -2,10 +2,10 @@
 
 
 def class_wrapper(cls: Type, target: Type) -> Type:
-    class NewClass(cls, target):
+    class WrappedTypeExtendedClass(cls, target):
         def __init__(self, *args, **kwargs):
             cls.__init__(self, *args, **kwargs)
             target.__init__(self, *args, **kwargs)
 
-    NewClass.__name__ = cls.__name__
-    return NewClass
+    WrappedTypeExtendedClass.__name__ = cls.__name__
+    return WrappedTypeExtendedClass