fastgenerateapi 0.0.23__py2.py3-none-any.whl → 0.0.25__py2.py3-none-any.whl

fastgenerateapi/my_fields/enum_field.py

@@ -0,0 +1,215 @@
+from enum import IntEnum
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    Generic,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    overload,
+)
+
+from fastapi import HTTPException
+from tortoise.fields.data import IntEnumFieldInstance
+
+if TYPE_CHECKING:  # pragma: nocoverage
+    from tortoise.models import Model
+
+
+class IntEnumField(IntEnumFieldInstance):
+    """
+    传入参数数组，默认生成枚举类，数字从 1 开始
+    例如：
+        enum_list = ["A", "B"]
+    相当于枚举
+        class CategoryEnum(IntEnum):
+            one = 1
+            two = 2
+    通过方法 get_name 获取对应的值， "A"
+    """
+
+    def __init__(self, enum_list: List[any], **kwargs: Any) -> None:
+        kwargs.setdefault("description", self.get_description(enum_list))
+        self.enum_list = enum_list
+        self.description = kwargs.get("description")
+        super().__init__(enum_type=self.create_enum(enum_list), **kwargs)
+
+    @property
+    def constraints(self) -> dict:
+        return {
+            "ge": 0,
+            "le": len(self.enum_list),
+        }
+
+    def to_db_value(self, value: Any, instance: "Union[Type[Model], Model]") -> Any:
+        """
+        Converts from the Python type to the DB type.
+        """
+        if value is not None:
+            value = int(value)  # pylint: disable=E1102
+            if value > len(self.enum_list) or 0 > value:
+                raise HTTPException(detail=f"枚举值：{value} 校验失败。【{self.description}】", status_code=422)
+        self.validate(value)
+        return value
+
+    def to_python_value(self, value: Any) -> Any:
+        """
+        Converts from the DB type to the Python type.
+        """
+        if value is not None:
+            value = int(value)  # pylint: disable=E1102
+        self.validate(value)
+        return IntEnumClass(value, self.enum_list)
+
+    def get_description(self, enum_list):
+        description = ""
+        for index, val in enumerate(enum_list, 1):
+            description += f"{index}:{val};"
+        return description
+
+    def create_enum(self, enum_list):
+        # 创建枚举类的成员字典，确保值是唯一的
+
+        members = {self.number_to_words(name): name for name, _ in enumerate(enum_list, 1)}
+
+        # 使用Enum的元类EnumMeta来动态创建枚举类
+        enum_class = IntEnum("CategoryEnum", members)
+
+        # 返回创建的枚举类
+        return enum_class
+
+    def number_to_words(self, num):
+        # 定义数字到单词的映射
+        ones = ['', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten',
+                'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen']
+        tens = ['', '', 'twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety']
+
+        if num == 0:
+            return 'zero'
+
+        if num < 20:
+            return ones[num]
+
+        if num < 100:
+            ten_digit = num // 10
+            one_digit = num % 10
+            if one_digit == 0:
+                return tens[ten_digit]
+            else:
+                return tens[ten_digit] + '_' + ones[one_digit]
+
+        if num < 1000:
+            hundred_digit = num // 100
+            remaining = num % 100
+            return ones[hundred_digit] + '_hundred_' + self.number_to_words(remaining)
+
+            # 对于大于1000的数字，可以进一步扩展这个函数来处理
+        # 但请注意，标准的英文数字读法会变得复杂，涉及"thousand", "million", "billion"等词
+
+        # 这里仅处理到9999，如果需要处理更大的数字，请继续扩展这个函数
+        thousand_digit = num // 1000
+        remaining = num % 1000
+        return self.number_to_words(thousand_digit) + '_thousand_' + self.number_to_words(remaining)
+
+
+class IntEnumClass:
+    def __init__(self, value: int, name_list: list):
+        self.value = value
+        self.name_list = name_list
+
+    def __str__(self):
+        return f"{self.value}"
+
+    @property
+    def name(self):
+        try:
+            return self.name_list[self.value-1]
+        except:
+            return self.value
+
+    def __add__(self, other: Union["IntEnumClass", int]):
+        if isinstance(other, IntEnumClass):
+            return IntEnumClass(self.value + other.value, self.name_list)
+        elif isinstance(other, int):
+            return IntEnumClass(self.value + other, self.name_list)
+        else:
+            raise TypeError(f"unsupported operand type(s) for +: 'NamedInt' and '{type(other).__name__}'")
+
+    def __sub__(self, other: Union["IntEnumClass", int]):
+        if isinstance(other, IntEnumClass):
+            return IntEnumClass(self.value - other.value, self.name_list)
+        elif isinstance(other, int):
+            return IntEnumClass(self.value - other, self.name_list)
+        else:
+            raise TypeError(f"unsupported operand type(s) for -: 'IntEnumClass' and '{type(other).__name__}'")
+
+    def __mul__(self, other: Union["IntEnumClass", int]):
+        if isinstance(other, IntEnumClass):
+            return IntEnumClass(self.value * other.value, self.name_list)
+        elif isinstance(other, int):
+            return IntEnumClass(self.value * other, self.name_list)
+        else:
+            raise TypeError(f"unsupported operand type(s) for *: 'IntEnumClass' and '{type(other).__name__}'")
+
+    def __truediv__(self, other: Union["IntEnumClass", int]):
+        if isinstance(other, IntEnumClass):
+            if other.value == 0:
+                raise ZeroDivisionError("division by zero")
+            return IntEnumClass(self.value // other.value, self.name_list)
+        elif isinstance(other, int):
+            if other == 0:
+                raise ZeroDivisionError("division by zero")
+            return IntEnumClass(self.value // other, self.name_list)
+        else:
+            raise TypeError(f"unsupported operand type(s) for /: 'IntEnumClass' and '{type(other).__name__}'")
+
+    def __eq__(self, other: Union["IntEnumClass", int]):
+        if isinstance(other, IntEnumClass):
+            return self.value == other.value
+        elif isinstance(other, int):
+            return self.value == other
+        return NotImplemented
+
+    def __ne__(self, other: Union["IntEnumClass", int]):
+        result = self.__eq__(other)
+        if result is NotImplemented:
+            return result
+        return not result
+
+    def __lt__(self, other: Union["IntEnumClass", int]):
+        if isinstance(other, IntEnumClass):
+            return self.value < other.value
+        elif isinstance(other, int):
+            return self.value < other
+        return NotImplemented
+
+    def __le__(self, other: Union["IntEnumClass", int]):
+        if isinstance(other, IntEnumClass):
+            return self.value <= other.value
+        elif isinstance(other, int):
+            return self.value <= other
+        return NotImplemented
+
+    def __gt__(self, other: Union["IntEnumClass", int]):
+        if isinstance(other, IntEnumClass):
+            return self.value > other.value
+        elif isinstance(other, int):
+            return self.value > other
+        return NotImplemented
+
+    def __ge__(self, other: Union["IntEnumClass", int]):
+        if isinstance(other, IntEnumClass):
+            return self.value >= other.value
+        elif isinstance(other, int):
+            return self.value >= other
+        return NotImplemented
+
+
+
+
+

fastgenerateapi/my_fields/pk_field.py

@@ -0,0 +1,68 @@
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    Generic,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    overload,
+)
+from tortoise.fields import Field
+
+if TYPE_CHECKING:  # pragma: nocoverage
+    from tortoise.models import Model
+
+from fastgenerateapi.utils.snowflake import worker
+
+
+class PrimaryKeyField(Field[str], str):
+    """
+    Big integer field. (64-bit signed)
+    """
+
+    SQL_TYPE = "BIGINT"
+    allows_generated = True
+
+    def __init__(self, **kwargs: Any) -> None:
+        kwargs["generated"] = False
+        kwargs["unique"] = True
+        kwargs["description"] = "主键"
+        kwargs["default"] = worker.get_id
+        super().__init__(pk=True, **kwargs)
+
+    def to_db_value(self, value: Any, instance: "Union[Type[Model], Model]") -> Any:
+        """
+        Converts from the Python type to the DB type.
+        """
+        if value is not None:
+            value = int(value)  # pylint: disable=E1102
+        self.validate(value)
+        return value
+
+    def to_python_value(self, value: Any) -> Any:
+        """
+        Converts from the DB type to the Python type.
+        """
+        if value is not None:
+            value = str(value)  # pylint: disable=E1102
+        self.validate(value)
+        return value
+
+
+
+
+
+
+
+
+
+
+
+
+
+

fastgenerateapi/my_fields/pwd_field.py

@@ -0,0 +1,81 @@
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    Generic,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    overload,
+)
+
+from passlib.handlers.pbkdf2 import pbkdf2_sha256
+from tortoise.fields import CharField
+if TYPE_CHECKING:  # pragma: nocoverage
+    from tortoise.models import Model
+
+
+class PasswordField(CharField):
+    """
+    Character field.
+
+    You must provide the following:
+
+    ``salt`` (str):
+    """
+
+    def __init__(self, salt: str, rounds=1000, **kwargs: Any) -> None:
+        kwargs.setdefault("max_length", 255)
+        kwargs.setdefault("description", "密码")
+        self.salt = salt
+        self.rounds = rounds
+        super().__init__(**kwargs)
+
+    def to_db_value(self, value: Any, instance: "Union[Type[Model], Model]") -> Any:
+        """
+        Converts from the Python type to the DB type.
+        """
+        if value is not None:
+            if not isinstance(value, self.field_type):
+                value = self.field_type(value)  # pylint: disable=E1102
+            custom_pbkdf2 = pbkdf2_sha256.using(salt=self.salt.encode('utf-8'), rounds=self.rounds)
+            value = custom_pbkdf2.hash(value)
+
+        self.validate(value)
+        return value
+
+    def to_python_value(self, value: Any) -> Any:
+        """
+        Converts from the DB type to the Python type.
+        """
+        if value is not None and not isinstance(value, self.field_type):
+            value = PasswordString(self.field_type(value), self.salt, self.rounds)  # pylint: disable=E1102
+        self.validate(value)
+        return value
+
+
+class PasswordString(str):
+    def __init__(self, password, salt, rounds):
+        self.value = password
+        self.salt = salt
+        self.rounds = rounds
+        super().__init__()
+
+    def __str__(self):
+        return self.value
+
+    def check_valid(self, password: str) -> bool:
+        """
+        检查密码是否正确
+        """
+        custom_pbkdf2 = pbkdf2_sha256.using(salt=self.salt.encode('utf-8'), rounds=self.rounds)
+        return self.password == custom_pbkdf2.hash(password)
+
+
+
+
+

fastgenerateapi/my_fields/soft_delete_field.py

@@ -0,0 +1,54 @@
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    Generic,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    overload,
+)
+from tortoise.fields import IntField
+if TYPE_CHECKING:  # pragma: nocoverage
+    from tortoise.models import Model
+
+
+class SoftDeleteField(IntField):
+    """
+    Integer field. (64-bit signed)
+    """
+
+    allows_generated = False
+
+    def __init__(self, **kwargs: Any) -> None:
+        kwargs.setdefault("index", True)
+        kwargs.setdefault("null", True)
+        kwargs.setdefault("default", None)
+        kwargs.setdefault("description", "软删除")
+        super().__init__(**kwargs)
+
+    def to_db_value(self, value: Any, instance: "Union[Type[Model], Model]") -> Any:
+        """
+        Converts from the Python type to the DB type.
+        """
+        if value is not None and not isinstance(value, self.field_type):
+            value = self.field_type(value)  # pylint: disable=E1102
+            if value == 0:
+                value = None
+        self.validate(value)
+        return value
+
+    def to_python_value(self, value: Any) -> Any:
+        """
+        Converts from the DB type to the Python type.
+        """
+        if value is not None and not isinstance(value, self.field_type):
+            value = self.field_type(value)  # pylint: disable=E1102
+        self.validate(value)
+        return value
+
+

fastgenerateapi/schemas_factory/common_function.py

@@ -63,7 +63,8 @@ def get_field_info_from_model_class(model_class: Type[Model], field: str, descri
             return Optional[str], FieldInfo(default=None, description=f"{field}")
         return get_field_info(value, description=description)
 
-    if field_info := model_class._meta.fields_map.get(field.split("__", maxsplit=1)[0]):
+    field_info = model_class._meta.fields_map.get(field.split("__", maxsplit=1)[0])
+    if field_info:
         description += field_info.description or ""
 
     model_class = DBModelMixin._get_foreign_key_relation_class(model_class, field.split("__", maxsplit=1)[0])

fastgenerateapi/schemas_factory/common_schema_factory.py

@@ -26,7 +26,7 @@ def common_schema_factory(
     include_fields = set()
     exclude_fields = set()
     if exclude_readonly:
-        exclude_fields.update(["id", "is_active", "created_at", "modified_at", "updated_at"])
+        exclude_fields.update(["id", "is_active", "deleted_at", "created_at", "modified_at", "updated_at"])
     if hasattr(model_class, "PydanticMeta"):
         if hasattr(model_class.PydanticMeta, "include"):
             include_fields_dict = get_dict_from_pydanticmeta(model_class, model_class.PydanticMeta.include)

fastgenerateapi/schemas_factory/create_schema_factory.py

@@ -34,10 +34,16 @@ def create_schema_factory(
             include_fields.update(all_fields_info.keys())
         if hasattr(model_class.PydanticMeta, "exclude"):
             exclude_fields.update(model_class.PydanticMeta.exclude)
+        if hasattr(model_class.PydanticMeta, "save_include"):
+            save_include_fields_dict = get_dict_from_pydanticmeta(model_class, model_class.PydanticMeta.save_include)
+            all_fields_info.update(save_include_fields_dict)
+            include_fields.update(save_include_fields_dict.keys())
         if hasattr(model_class.PydanticMeta, "create_include"):
-            get_one_include_fields_dict = get_dict_from_pydanticmeta(model_class, model_class.PydanticMeta.create_include)
-            all_fields_info.update(get_one_include_fields_dict)
-            include_fields.update(get_one_include_fields_dict.keys())
+            create_include_fields_dict = get_dict_from_pydanticmeta(model_class, model_class.PydanticMeta.create_include)
+            all_fields_info.update(create_include_fields_dict)
+            include_fields.update(create_include_fields_dict.keys())
+        if hasattr(model_class.PydanticMeta, "save_exclude"):
+            exclude_fields.update(model_class.PydanticMeta.save_exclude)
         if hasattr(model_class.PydanticMeta, "create_exclude"):
             exclude_fields.update(model_class.PydanticMeta.create_exclude)
     else:

fastgenerateapi/schemas_factory/get_all_schema_factory.py

@@ -40,6 +40,13 @@ def get_all_schema_factory(
     if hasattr(model_class.PydanticMeta, "exclude"):
         exclude_fields.update(model_class.PydanticMeta.exclude)
 
+    if hasattr(model_class.PydanticMeta, "get_include"):
+        get_include_fields_dict = get_dict_from_pydanticmeta(model_class, model_class.PydanticMeta.get_include)
+        all_fields_info.update(get_include_fields_dict)
+        include_fields.update(get_include_fields_dict.keys())
+    if hasattr(model_class.PydanticMeta, "get_exclude"):
+        exclude_fields.update(model_class.PydanticMeta.get_exclude)
+
     # get_all_include
     if hasattr(model_class.PydanticMeta, "get_all_include"):
         get_all_include_fields_dict = get_dict_from_pydanticmeta(model_class, model_class.PydanticMeta.get_all_include)

fastgenerateapi/schemas_factory/get_one_schema_factory.py

@@ -33,6 +33,14 @@ def get_one_schema_factory(
             include_fields.update(all_fields_info.keys())
         if hasattr(model_class.PydanticMeta, "exclude"):
             exclude_fields.update(model_class.PydanticMeta.exclude)
+
+        if hasattr(model_class.PydanticMeta, "get_include"):
+            get_include_fields_dict = get_dict_from_pydanticmeta(model_class, model_class.PydanticMeta.get_include)
+            all_fields_info.update(get_include_fields_dict)
+            include_fields.update(get_include_fields_dict.keys())
+        if hasattr(model_class.PydanticMeta, "get_exclude"):
+            exclude_fields.update(model_class.PydanticMeta.get_exclude)
+
         if hasattr(model_class.PydanticMeta, "get_one_include"):
             get_one_include_fields_dict = get_dict_from_pydanticmeta(model_class, model_class.PydanticMeta.get_one_include)
             all_fields_info.update(get_one_include_fields_dict)

fastgenerateapi/schemas_factory/get_tree_schema_factory.py

@@ -38,6 +38,14 @@ def get_tree_schema_factory(
             include_fields.update(include_fields_dict.keys())
         else:
             include_fields.update(all_fields_info.keys())
+
+        if hasattr(model_class.PydanticMeta, "get_include"):
+            get_include_fields_dict = get_dict_from_pydanticmeta(model_class, model_class.PydanticMeta.get_include)
+            all_fields_info.update(get_include_fields_dict)
+            include_fields.update(get_include_fields_dict.keys())
+        if hasattr(model_class.PydanticMeta, "get_exclude"):
+            exclude_fields.update(model_class.PydanticMeta.get_exclude)
+
         if hasattr(model_class.PydanticMeta, "get_tree_exclude"):
             exclude_fields.update(model_class.PydanticMeta.get_tree_exclude)
         if hasattr(model_class.PydanticMeta, "exclude"):

fastgenerateapi/schemas_factory/update_schema_factory.py

@@ -34,10 +34,16 @@ def update_schema_factory(
             include_fields.update(all_fields_info.keys())
         if hasattr(model_class.PydanticMeta, "exclude"):
             exclude_fields.update(model_class.PydanticMeta.exclude)
+        if hasattr(model_class.PydanticMeta, "save_include"):
+            save_include_fields_dict = get_dict_from_pydanticmeta(model_class, model_class.PydanticMeta.save_include)
+            all_fields_info.update(save_include_fields_dict)
+            include_fields.update(save_include_fields_dict.keys())
         if hasattr(model_class.PydanticMeta, "update_include"):
-            get_one_include_fields_dict = get_dict_from_pydanticmeta(model_class, model_class.PydanticMeta.update_include)
-            all_fields_info.update(get_one_include_fields_dict)
-            include_fields.update(get_one_include_fields_dict.keys())
+            update_include_fields_dict = get_dict_from_pydanticmeta(model_class, model_class.PydanticMeta.update_include)
+            all_fields_info.update(update_include_fields_dict)
+            include_fields.update(update_include_fields_dict.keys())
+        if hasattr(model_class.PydanticMeta, "save_exclude"):
+            exclude_fields.update(model_class.PydanticMeta.update_exclude)
         if hasattr(model_class.PydanticMeta, "update_exclude"):
             exclude_fields.update(model_class.PydanticMeta.update_exclude)
     else:

fastgenerateapi/settings/settings.py

@@ -29,12 +29,12 @@ class AppSettings(BaseSettings):
     ROUTER_WHETHER_UNDERLINE_TO_STRIKE: Optional[bool] = Field(default=False, description="路由是否下划线转中划线")
     ROUTER_WHETHER_ADD_SUFFIX: Optional[bool] = Field(default=True, description="增删改查路由是否添加后缀")
     ROUTER_CREATE_SUFFIX_FIELD: Optional[str] = Field(default='create', description="创建路由后缀字段")
-    ROUTER_GET_ONE_SUFFIX_FIELD: Optional[str] = Field(default='get-one', description="获取一个路由后缀字段")
-    ROUTER_GET_ALL_SUFFIX_FIELD: Optional[str] = Field(default='get-all', description="获取列表路由后缀字段")
-    ROUTER_GET_TREE_SUFFIX_FIELD: Optional[str] = Field(default='get-tree', description="获取树状数据路由后缀字段")
+    ROUTER_GET_ONE_SUFFIX_FIELD: Optional[str] = Field(default='get_one', description="获取一个路由后缀字段")
+    ROUTER_GET_ALL_SUFFIX_FIELD: Optional[str] = Field(default='get_all', description="获取列表路由后缀字段")
+    ROUTER_GET_TREE_SUFFIX_FIELD: Optional[str] = Field(default='get_tree', description="获取树状数据路由后缀字段")
     ROUTER_UPDATE_SUFFIX_FIELD: Optional[str] = Field(default='update', description="修改路由后缀字段")
     ROUTER_DELETE_SUFFIX_FIELD: Optional[str] = Field(default='delete', description="删除路由后缀字段")
-    ROUTER_RECURSION_DELETE_SUFFIX_FIELD: Optional[str] = Field(default='delete-tree', description="递归删除路由后缀字段")
+    ROUTER_RECURSION_DELETE_SUFFIX_FIELD: Optional[str] = Field(default='delete_tree', description="递归删除路由后缀字段")
 
     # 函数转换路由时，默认添加字段，（遵循restful规范时，get路由处理方案）
     RESTFUL_GET_ROUTER_ADD_PREFIX: Optional[str] = Field(default='', description="函数转换路由时：前缀添加字段")
@@ -46,9 +46,14 @@ class AppSettings(BaseSettings):
     RESTFUL_DELETE_ROUTER_ADD_PREFIX: Optional[str] = Field(default='', description="函数转换路由时：前缀添加字段")
     RESTFUL_DELETE_ROUTER_ADD_SUFFIX: Optional[str] = Field(default='', description="函数转换路由时：后缀pk前添加字段")
 
+    # 分布式id
+    WORKER_ID: Optional[int] = Field(default=1, description="数据中心（机器区域）ID")
+    DATACENTER_ID: Optional[int] = Field(default=1, description="机器ID")
+
     # 数据库字段默认值
-    WHETHER_DELETE_FIELD: Optional[str] = Field(default="is_active", description="是否删除字段")
-    ACTIVE_DEFAULT_VALUE: Optional[bool] = Field(default=True, description="有效的默认值")
+    WHETHER_DELETE_FIELD: Optional[str] = Field(default="deleted_at", description="是否删除字段;推荐命名 >> deleted_at;is_active")
+    DELETE_FIELD_TYPE: Optional[str] = Field(default="time", description="删除字段类型;推荐命名 >> time;bool")
+    # ACTIVE_DEFAULT_VALUE: Optional[bool] = Field(default=True, description="有效的默认值")
     GET_EXCLUDE_ACTIVE_VALUE: Optional[bool] = Field(default=True, description="查询结果是否排除有效字段")
     CREATE_EXCLUDE_ACTIVE_VALUE: Optional[bool] = Field(default=True, description="创建是否排除有效字段")
     UPDATE_EXCLUDE_ACTIVE_VALUE: Optional[bool] = Field(default=True, description="修改是否排除有效字段")
@@ -70,7 +75,7 @@ class AppSettings(BaseSettings):
     SCHEMAS_UNDERLINE_WHETHER_DOUBLE_TO_SINGLE: Optional[bool] = Field(default=True, description="序列化字段是否双下划线转单下划线")
 
     class Config:
-        # env_prefix = 'APP_'
+        env_prefix = 'APP_'
         env_file = "./.env"
         case_sensitive = True
 

fastgenerateapi/utils/aes.py

@@ -0,0 +1,93 @@
+from typing import Union
+
+from Crypto import Random
+from Crypto.Cipher import AES
+import base64
+
+
+class AESCipher(object):
+    """
+    可用于二进制(文件)和字符串加密
+    """
+    def __init__(self, salt):
+        '''
+        CBC加密需要一个十六位的key(密钥)和一个十六位iv(偏移量)
+        '''
+        self.salt = self.check_key(salt)
+        # 这里使用随机偏移量
+        # self.iv = self.check_key(iv) if iv else self.salt
+        # 数据块的大小  16位
+        self.BS = AES.block_size
+        # CBC模式 相对安全 因为有偏移向量 iv 也是16位字节的
+        self.mode = AES.MODE_CBC
+        # 填充函数 因为AES加密是一段一段加密的  每段都是BS位字节，不够的话是需要自己填充的
+        self.pad = lambda s: s + (self.BS - len(s) % self.BS) * chr(self.BS - len(s) % self.BS).encode('utf-8')
+        # 将填充的数据剔除
+        self.unpad = lambda s: s[:-ord(s[len(s) - 1:])]
+
+    def encrypt(self, text: Union[bytes, str]) -> bytes:
+        text = self.check_data(text)
+        text = self.pad(text)
+        # 随机获取iv
+        iv = Random.new().read(AES.block_size)
+        # 初始化自定义
+        cipher = AES.new(self.salt, self.mode, iv)
+        # 此处是将密文和iv一起 base64 解密的时候就可以根据这个iv来解密
+        return base64.b64encode(iv + cipher.encrypt(text))
+        # return base64.b64encode(iv + cipher.encrypt(text)).decode("utf-8")
+
+    def decrypt(self, text: Union[bytes, str, int]) -> bytes:
+        text = self.check_data(text)
+        # 先将密文进行base64解码
+        text = base64.b64decode(text)
+        # 取出iv值
+        iv = text[:self.BS]
+        # 初始化自定义
+        cipher = AES.new(self.salt, self.mode, iv)
+        return self.unpad(cipher.decrypt(text[self.BS:]))
+        # return self.unpad(cipher.decrypt(text[self.BS:])).decode("utf-8")
+
+    def check_key(self, key: Union[bytes, str]) -> bytes:
+        '''
+            检测key的长度是否为16,24或者32bytes的长度
+        '''
+        if isinstance(key, bytes):
+            assert len(key) in [16, 24, 32]
+            return key
+        elif isinstance(key, str):
+            assert len(key.encode("utf-8")) in [16, 24, 32]
+            return key.encode("utf-8")
+        else:
+            raise Exception(f'密钥必须为str或bytes,不能为{type(key)}')
+
+    def check_data(self, data: Union[bytes, str, int]) -> bytes:
+        '''
+        检测加密的数据类型
+        '''
+        if isinstance(data, int):
+            data = str(data).encode('utf-8')
+        elif isinstance(data, str):
+            data = data.encode('utf-8')
+        elif isinstance(data, bytes):
+            pass
+        else:
+            raise Exception(f'加密的数据必须为str或bytes,不能为{type(data)}')
+        return data
+
+
+# if __name__ == '__main__':
+#     # 加密字符串
+#     import json
+#     # aes_encrypt = AESCipher('ningbozhihuirend')  # 自己设定的密钥
+#     aes_encrypt = AESCipher('ningbozhihuirend')  # 自己设定的密钥
+#     data = json.dumps({"mobile": "1312345646", "content": "xczczczc"})
+#     print(type(data))
+#     print(data)
+#     e = aes_encrypt.encrypt(data).decode("utf-8")  # 加密内容
+#     print(type(e))
+#     print(e)
+#     d = aes_encrypt.decrypt(e).decode("utf-8")
+#     print(type(d))
+#     print(json.loads(d))
+#     print(len(e))
+#     print("加密后%s,解密后%s" % (e, d))