fastgenerateapi 0.0.28__py2.py3-none-any.whl → 1.1.7__py2.py3-none-any.whl

fastgenerateapi/settings/otlp_settings.py

@@ -0,0 +1,69 @@
+from typing import Optional
+
+import httpx
+from fastapi import FastAPI
+from opentelemetry import metrics, trace
+from opentelemetry.exporter.otlp.proto.http.metric_exporter import OTLPMetricExporter
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
+from opentelemetry.instrumentation.httpx import HTTPXClientInstrumentor
+from opentelemetry.instrumentation.tortoiseorm import TortoiseORMInstrumentor
+from opentelemetry.sdk.metrics import MeterProvider
+from opentelemetry.sdk.metrics._internal.export import PeriodicExportingMetricReader
+from opentelemetry.sdk.resources import Resource, SERVICE_NAME
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class OpenTelemetrySettings(BaseSettings):
+    """
+    跟踪和指标配置
+    """
+    ENDPOINT: Optional[str] = Field(default=None, description="访问接口", example="http://127.0.0.1")
+    AUTHORIZATION: Optional[str] = Field(default=None, description="认证字符串")
+
+    def setup_open_telemetry(self, app: FastAPI, service_name: str):
+        if not self.ENDPOINT:
+            return
+
+        with httpx.Client() as client:
+            health_check = client.get(f"{self.ENDPOINT}/healthz", timeout=3).json()
+            if health_check["status"] != "ok":
+                raise Exception("otlp服务异常")
+            resource = Resource(attributes={
+                SERVICE_NAME: service_name
+            })
+
+            tracer_provider = TracerProvider(resource=resource)
+            headers = {
+                "Authorization": self.AUTHORIZATION} if self.AUTHORIZATION else {}
+            exporter = OTLPMetricExporter(
+                endpoint=f"{self.ENDPOINT}/api/default/v1/metrics",
+                headers=headers,
+            )
+            meter_provider = MeterProvider([PeriodicExportingMetricReader(exporter)], resource=resource)
+            metrics.set_meter_provider(meter_provider)
+            processor = BatchSpanProcessor(
+                OTLPSpanExporter(
+                    endpoint=f"{self.ENDPOINT}/api/default/v1/traces",
+                    headers=headers
+                )
+            )
+            tracer_provider.add_span_processor(processor)
+            trace.set_tracer_provider(tracer_provider)
+            FastAPIInstrumentor.instrument_app(
+                app,
+                tracer_provider=tracer_provider,
+                meter_provider=meter_provider,
+            )
+            TortoiseORMInstrumentor().instrument(tracer_provider=tracer_provider)
+            HTTPXClientInstrumentor().instrument(tracer_provider=tracer_provider)
+
+    class Config:
+        env_prefix = 'OTLP_'
+        env_file = "./.env"
+        case_sensitive = True
+        extra = 'allow'

fastgenerateapi/settings/redis_settings.py

@@ -0,0 +1,16 @@
+from typing import Optional
+
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class RedisSettings(BaseSettings):
+    URL: Optional[str] = Field(default="redis://127.0.0.1", description="IP地址")
+    PORT: Optional[int] = Field(default=6379, description="映射端口")
+    PASSWORD: Optional[str] = Field(default="", description="密码")
+
+    class Config:
+        env_prefix = 'REDIS_'
+        env_file = "./.env"
+        case_sensitive = True
+        extra = 'allow'

fastgenerateapi/settings/sms_settings.py

@@ -0,0 +1,25 @@
+from typing import Optional
+
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class SmsSettings(BaseSettings):
+    """
+        短信配置
+        Sms Settings
+    """
+    CACHE_BACKEND: Optional[str] = Field(default="redis", description="缓存类型", title="cache_backend(redis, inmemory)")
+    CACHE_BACKEND_DSN: Optional[str] = Field(default="redis://localhost:6379/1", description="缓存dsn", title="cache_backend_dsn")
+    IS_LIMIT_CODE_FREQUENCY: Optional[bool] = Field(default=True, description="是否限制频率", title="code frequency check")
+    CHECK_CODE_RESEND_TIME: Optional[int] = Field(default=1, description="验证码重新发送时间", title="check code resend time (minute)")
+    DEFAULT_CODE: Optional[int] = Field(default="654123", description="默认验证码", title="sms default code")
+
+    class Config:
+        env_prefix = 'Sms_'
+        env_file = "./.env"
+        case_sensitive = True
+        extra = 'allow'
+
+
+

fastgenerateapi/settings/system_settings.py

@@ -0,0 +1,30 @@
+from typing import Optional
+
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class SystemSettings(BaseSettings):
+    """
+        System Settings
+    """
+    NAME: str = Field(default='fastgenerateapi', description="项目名称")
+    HOST: Optional[str] = Field(default='127.0.0.1', description="本地运行host")
+    PORT: Optional[int] = Field(default=8001, description="本地运行port")
+    DEBUG: bool = Field(default=True, description="是否开启调试模式，本地修改自动重载")
+
+    # BASE_DIR: Union[PathType, str, None]
+    DOMAIN: Optional[str] = Field(default="http://127.0.0.1:8001", description="服务域名（对外暴露的域名地址包含协议）")
+    FIELD_SECRET: Optional[str] = Field(default=None, description="字段加密密钥")
+
+    # 分布式id
+    WORKER_ID: Optional[int] = Field(default='1', description="数据中心（机器区域）ID")
+    DATACENTER_ID: Optional[int] = Field(default='1', description="机器ID")
+
+    class Config:
+        env_prefix = ''
+        env_file = "./.env"
+        case_sensitive = True
+        extra = 'allow'
+
+

fastgenerateapi/utils/auto_discover.py

@@ -0,0 +1,61 @@
+import importlib
+import os
+from pathlib import Path
+from typing import Optional, List
+
+
+def get_path_list(path: str, match_prefix: str, prefix: str = "") -> List[str]:
+    files = []
+    prefix = prefix + "." + os.path.basename(path) if prefix else os.path.basename(path)
+    for item in Path(path).iterdir():
+        if item.is_file():
+            if item.name.startswith(match_prefix) and item.name.endswith(".py"):
+                files.append(prefix+"."+item.name[:-3])
+        elif item.is_dir():
+            if item.name.startswith(match_prefix):
+                for s_item in Path(os.path.join(path, item.name)).iterdir():
+                    if s_item.is_file() and s_item.name.startswith(match_prefix):
+                        files.append(prefix + "." + item.name + "." + s_item.name[:-3])
+            else:
+                files += get_path_list(os.path.join(path, item.name), match_prefix, prefix)
+
+    return files
+
+
+def discover_models(
+        base_path="apps",  # 模块路径
+        include: Optional[List[str]] = None,  # 包含的模型
+        exclude: Optional[List[str]] = None,  # 排除的模型
+) -> List[str]:
+    """
+    自动发现models，并生成tortoise-orm所需要的字符串
+    会自动添加 aerich.models，如不需要请在 exclude 参数排除
+    """
+    models_list = ["aerich.models"] + get_path_list(base_path, "models")
+    return include + [model for model in models_list if model not in exclude] if exclude else models_list
+
+
+def discover_routes(
+        app,  # Fastapi 生成的实体类
+        base_path="apps",  # 模块路径
+        prefix="",  # 路由前缀
+        include: Optional[List[str]] = None,  # 包含的路由
+        exclude: Optional[List[str]] = None,  # 排除的路由
+):
+    """自动发现路由，并注册"""
+    paths = include if include else []
+
+    for path in paths + get_path_list(base_path, "router"):
+        if exclude and path in exclude:
+            continue
+        module = importlib.import_module(path)
+        if hasattr(module, "router"):
+            app.include_router(prefix=prefix, router=getattr(module, "router"))
+    return app
+
+
+if __name__ == '__main__':
+    # print(discover_models("../../modules"))
+    print(get_path_list("../../modules", "router"))
+
+

fastgenerateapi/utils/file_utils.py

@@ -0,0 +1,76 @@
+import struct
+
+type_dict = {
+    # '424D': 'bmp',
+    'FFD8FF': 'jpg',
+    # '2E524D46': 'rm',
+    # '4D546864': 'mid',
+    '89504E47': 'png',
+    '47494638': 'gif',
+    '49492A00': 'tif',
+    # '41433130': 'dwg',
+    # '38425053': 'psd',
+    # '2142444E': 'pst',
+    # 'FF575043': 'wpd',
+    # 'AC9EBD8F': 'qdf',
+    # 'E3828596': 'pwl',
+    '504B0304': 'zip',
+    '52617221': 'rar',
+    '57415645': 'wav',
+    '41564920': 'avi',
+    '2E7261FD': 'ram',
+    '000001BA': 'mpg',
+    '000001B3': 'mpg',
+    '6D6F6F76': 'mov',
+    # '7B5C727466': 'rtf',
+    '3C3F786D6C': 'xml',
+    '68746D6C3E': 'html',
+    'D0CF11E0': 'doc/xls',
+    '255044462D312E': 'pdf',
+    'CFAD12FEC5FD746F': 'dbx',
+    # '3026B2758E66CF11': 'asf',
+    '5374616E64617264204A': 'mdb',
+    # '252150532D41646F6265': 'ps/eps',
+    # '44656C69766572792D646174653A': 'eml'
+}
+max_len = len(max(type_dict, key=len)) // 2
+
+
+async def get_filetype(file):
+    # 读取二进制文件开头一定的长度
+    if isinstance(file, str):
+        filename = file
+        with open(filename, 'rb') as f:
+            byte = f.read(max_len)
+    else:
+        filename = file.filename
+        byte = await file.read(max_len)
+        await file.seek(0)
+    # 解析为元组
+    byte_list = struct.unpack('B' * max_len, byte)
+    # 转为16进制
+    code = ''.join([('%X' % each).zfill(2) for each in byte_list])
+    # 根据标识符筛选判断文件格式
+    result = list(filter(lambda x: code.startswith(x), type_dict))
+    nametype = filename.split('.')[-1]
+    if result:
+        filetype = type_dict[result[0]]
+        if filetype == "zip":
+            filetype = nametype if nametype in ['xlsx', 'docx'] else "zip"
+        elif filetype == "doc/xls":
+            filetype = nametype if nametype in ['doc', 'xls'] else None
+        elif filetype == "jpg":
+            filetype = nametype if nametype in ['jpg', 'jpeg'] else None
+        else:
+            filetype = filetype if filetype == nametype else None
+    else:
+        filetype = nametype if nametype in ['mp3', 'mp4', 'txt'] else None
+    return filetype
+
+file_type = {
+    "image": ["jpg", "png", "gif", "tif"],
+    "document": ["zip", "rar", "wav", "xml", "html", "doc", "xls", "pdf", "dbx", "mdb"],
+    "voice": ["mp3", "amr"],
+    "video": ["wav", "avi", "ram", "mpg", "mov", "mp4"],
+}
+

fastgenerateapi/utils/pwd_utils.py

@@ -0,0 +1,49 @@
+import random
+
+from passlib.hash import pbkdf2_sha256, md5_crypt
+
+
+def make_random_salt(length=64):
+    """
+        生成随机salt字符串，可指定长度
+    :param length: int
+    :return: salt: str
+    """
+    seed = "1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!#$&*="
+    sa = []
+    for i in range(length):
+        sa.append(random.choice(seed))
+    salt = ''.join(sa)
+    return salt
+
+
+def create_password_hash(password: str, salt: str) -> str:
+    """
+    根据传入的password与salt参数生成hash值
+    :param password:
+    :param salt:
+    :return:
+    """
+    custom_pbkdf2 = pbkdf2_sha256.using(salt=salt.encode('utf-8'), rounds=1000)
+    return custom_pbkdf2.hash(password)
+
+
+def validate_password(password: str, salt: str, password_hash: str) -> bool:
+    """
+    password 校验
+    :param password:
+    :param salt:
+    :param password_hash:
+    :return:
+    """
+    validating_password_hash = create_password_hash(password, salt)
+    return validating_password_hash == password_hash
+
+
+# if __name__ == '__main__':
+#     # salt = make_random_salt(length=60)
+#     salt = "lpiZRQwWoj&*wh29Jovk$uA3YGP$TSQYpM4ooy1z3zGuNT=vmLpb&Ves"
+#     hash_str = create_password_hash('123456132312312312312321', salt)
+#     print(hash_str)
+#     print(len(hash_str))
+#     print(validate_password(password='123456132312312312312321', salt=salt, password_hash=hash_str))

fastgenerateapi/utils/ramdom_utils.py

@@ -0,0 +1,48 @@
+import hashlib
+import random
+import uuid
+
+
+def get_code(n=4):
+    """
+    生成随机验证码，数字和字母的概率各一半
+    :param n: 验证码长度
+    :return: str
+    """
+    s = ''
+    for i in range(n):
+        ret_num = random.randint(0, 9)
+        ret_alpha = chr(random.randint(65, 90))
+        result = random.choice([ret_num, ret_alpha])
+        s += str(result)
+    return s
+
+
+def random_str() -> str:
+    """
+    唯一随机字符串
+    :return: str
+    """
+    only = hashlib.md5(str(uuid.uuid1()).encode(encoding='UTF-8')).hexdigest()
+    return str(only)
+
+
+def get_code_number(n: int = 6) -> str:
+    """
+    随机数字
+    :param n: 长度
+    :return: str
+    """
+    code = ""
+    for i in range(n):
+        ch = chr(random.randrange(ord('0'), ord('9') + 1))
+        code += ch
+
+    return code
+
+
+if __name__ == '__main__':
+    print(get_code())
+    print(random_str())
+    print(get_code_number(6))
+

fastgenerateapi/utils/snowflake.py

@@ -5,7 +5,7 @@ from fastapi.exceptions import RequestValidationError
 
 
 # 64位ID的划分
-from fastgenerateapi.settings.register_settings import settings
+from fastgenerateapi.settings.all_settings import settings
 
 WORKER_ID_BITS = 5   # 机器位
 DATACENTER_ID_BITS = 5    # 数据位
@@ -73,30 +73,31 @@ class IdWorker(object):
         """
         return int(time.time() * 1000)
 
-    def get_post_id(self):
+    def get_code(self, prefix: str = ""):
         """
-        获取新ID
+        获取有序编码,高并发不推荐使用，会出现重复值
         :return:
         """
-        timestamp = self._gen_timestamp()
+        def make_code():
+            timestamp = self._gen_timestamp()
 
-        # 时钟回拨
-        if timestamp < self.last_timestamp:
-            raise RequestValidationError
+            # 时钟回拨
+            if timestamp < self.last_timestamp:
+                raise RequestValidationError
 
-        if timestamp == self.last_timestamp:
-            self.sequence = (self.sequence + 1) & SEQUENCE_MASK
-            if self.sequence == 0:
-                timestamp = self._til_next_millis(self.last_timestamp)
-        else:
-            self.sequence = 0
+            if timestamp == self.last_timestamp:
+                self.sequence = (self.sequence + 1) & 7
+                if self.sequence == 0:
+                    timestamp = self._til_next_millis(self.last_timestamp)
+            else:
+                self.sequence = 0
 
-        self.last_timestamp = timestamp
+            self.last_timestamp = timestamp
 
-        # new_id = ((timestamp - TWEPOCH) << TIMESTAMP_LEFT_SHIFT) | (self.datacenter_id << DATACENTER_ID_SHIFT) | \
-        #          (self.worker_id << WOKER_ID_SHIFT) | self.sequence
-        new_id = ((timestamp - TWEPOCH) << TIMESTAMP_LEFT_SHIFT) | self.sequence
-        return 'PT' + str(new_id)
+            new_id = (int((timestamp - TWEPOCH) / 100) << 2) | (self.datacenter_id << 2) | \
+                     (self.worker_id << 2) | self.sequence
+            return prefix + str(new_id)
+        return make_code
 
     def get_id(self):
         """
@@ -139,8 +140,10 @@ class IdWorker(object):
 worker = IdWorker(datacenter_id=settings.app_settings.DATACENTER_ID, worker_id=settings.app_settings.WORKER_ID)
 
 
-# if __name__ == '__main__':
-#     # worker = IdWorker()
+if __name__ == '__main__':
+    # worker = IdWorker()
+    print(worker.get_code()())
+    print(worker.get_code("A")())
 #     pk = worker.get_id()
 #     print(pk)
 #     print(len(str(pk)), len("9223372036854775807"))

fastgenerateapi/utils/str_util.py

@@ -0,0 +1,120 @@
+from typing import Union, Optional, List
+
+from fastgenerateapi.settings.all_settings import settings
+
+
+def parse_str_to_bool(val: Union[int, str, bool, None]) -> bool:
+    """
+    解析字符串到布尔值
+    """
+    if type(val) == bool:
+        return val
+    elif type(val) == int:
+        return val != 0
+    elif type(val) == str:
+        if val.upper() in ("1", "ON", "TRUE"):
+            return True
+        elif val.upper() in ("0", "OFF", "FALSE"):
+            return False
+    return settings.app_settings.DEFAULT_WHETHER_PAGE
+
+
+def parse_str_to_int(val: Union[int, str, None]) -> int:
+    """
+    解析字符串到数值
+    """
+    if type(val) == int:
+        return val
+    elif type(val) == str:
+        try:
+            val = int(val)
+        except Exception as e:
+            val = 0
+        return val
+
+    return 0
+
+
+def parse_str_to_list(val: Optional[str], split_list: Optional[List[str]] = None) -> List[str]:
+    """
+    某些字段可能由、，,等拼接，字符串分割为列表
+    :param val:  我、你，他,她
+    :param split_list: 默认 ["、", "，", ","]
+    :return: ["我", "你", "他", "她"]
+    """
+    # 如果输入为空，返回空列表
+    if not val:
+        return []
+
+    # 设置默认分隔符列表
+    if split_list is None:
+        split_list = ["、", "，", ","]
+
+    # 初始化结果列表
+    result = [val]
+
+    # 遍历分隔符，逐步拆分字符串
+    for sep in split_list:
+        result = [item for sublist in result for item in sublist.split(sep)]
+
+    # 去除每个元素的前后空格
+    result = [item.strip() for item in result]
+
+    # 过滤掉空字符串
+    result = [item for item in result if item]
+
+    return result
+
+
+def number_to_chinese(num):
+    """
+    数字转换为大写中文，会自动带上整字
+    :param num:
+    :return:
+    """
+    if num == 0:
+        return "零元整"
+    dict1 = {1: '壹', 2: '贰', 3: '叁', 4: '肆', 5: '伍', 6: '陆', 7: '柒', 8: '捌', 9: '玖', 0: '零'}
+    dict2 = {2: '拾', 3: '佰', 4: '仟', 5: '万', 6: '拾', 7: '佰', 8: '仟', 1: '元', 9: '角', 10: '分', 11: '整'}
+    money = ''
+    flag = False
+    flag2 = False
+    count = 0
+    count2 = 8
+    strnum = str(num)
+    aa = strnum.split('.')
+    bb = list(str(aa[:1])[2:-2])
+    cc = list(str(aa[1]).rstrip("0")[:2]) if len(aa) > 1 else []
+
+    for i in reversed(bb):
+        count = count + 1
+        if int(i) == 0:
+            if flag:
+                if count != 5:
+                    continue
+                else:
+                    money = dict2[count] + money
+            else:
+                if not flag2:
+                    money = dict2[count] + money
+                else:
+                    if count != 5:
+                        money = '零' + money
+                    else:
+                        money = dict2[count] + '零' + money
+            flag = True
+        else:
+            flag = False
+            flag2 = True
+            money = dict1[int(i)] + dict2[count] + money
+    for i in cc:
+        count2 = count2 + 1
+        money = money + dict1[int(i)] + dict2[count2]
+
+    return money + '整'
+
+
+if __name__ == '__main__':
+    # test parse_str_to_list
+    print(parse_str_to_list("我、你，他,她"))
+    print(parse_str_to_list("我|你&他 她", split_list=["|", "&", " "]))

fastgenerateapi/utils/swagger_to_js.py

@@ -0,0 +1,26 @@
+from typing import Optional
+
+
+class SwaggerUtil:
+
+    @staticmethod
+    def swagger_to_js(swagger_json: Optional[dict]):
+        """
+        通过swagger文档自动生成js接口文件，方便前后端开发
+        如果 swagger_json 为空，
+        - 优先检查运行路径下的swagger.json文件
+        - 其次检查 127.0.0.1:8000/openapi.json 接口
+        :param swagger_json:
+        :return:
+        """
+        # 参考go zero 生成js文件的样式
+        
+        return
+
+
+
+
+
+
+
+