deepfos 1.1.60__py3-none-any.whl → 1.1.78__py3-none-any.whl

deepfos/api/models/base.py

@@ -1,234 +1,74 @@
-import json
-from collections import defaultdict
+from deepfos.lib.utils import to_version_tuple
+import pydantic
 
-from pydantic import BaseModel as PydanticBaseModel, Field, validator
-from pydantic.fields import FieldInfo
-# noinspection PyProtectedMember
-from pydantic.main import ModelMetaclass
-from pydantic.generics import GenericModel
-from typing import Any, TypeVar, Generic, no_type_check, Dict
+from typing import Any, Dict, TypeVar, Type
+from pydantic import BaseModel as PydanticBaseModel, ConfigDict
+from pydantic import parse_obj_as
+
+Pydantic_V2 = False
+if to_version_tuple(pydantic.__version__, max_split=2) > (2, 0, 0):
+    from pydantic import TypeAdapter
+    Pydantic_V2 = True
+else:
+    TypeAdapter = None
 
 __all__ = [
-    "HeaderModel",
-    "Response",
     "BaseModel",
-    "BaseModelPlus",
-    "Group",
-    "AutoField",
-    "GenericResponse",
-    "GResponse",
+    "compat_parse_obj_as",
 ]
 
+T = TypeVar('T')
 
-class Group(FieldInfo):
-    def __init__(self, default, group_id, at_least=1, at_most=1, **kwargs):
-        """
-        Args:
-            default: 默认值，同FieldInfo
-            group_id: 组ID，id相同并且属于同一个类的被视为同一组
-            at_least: 同组中至少需提供多少参数
-            at_most: 同组中至多可以提供多少参数
-            **kwargs: 同FieldInfo
-        """
-        self.at_most = at_most
-        self.at_least = at_least
-        self.group_id = group_id
-        super().__init__(default, **kwargs)
-
-
-class AutoField(FieldInfo):
-    pass
-
-
-def _enable_groupfield(group: Dict[str, Group]):
-    grp = list(group.values())[-1]
-    _field = list(group.keys())[-1]
-    at_least, at_most = grp.at_least, grp.at_most
-    restriction_msg = f"字段{list(group.keys())}至少需提供{at_least}个，" \
-                      f"至多{at_most}个。"
-    for g in group.values():
-        g.description = f"{g.description}({restriction_msg})"
-
-    # noinspection PyUnusedLocal
-    def _validator(cls, v, values, field):
-        assigned_fields = set(k for k, v in values.items() if v is not None)
-        if v is not None:
-            assigned_fields.add(field.name)
-
-        grp_assigned_fields = group.keys() & assigned_fields
-        if not at_least <= len(grp_assigned_fields) <= at_most:
-            if grp_assigned_fields:
-                field_info = f"实际赋值的字段为：{grp_assigned_fields}"
-            else:
-                field_info = "实际任何字段都未赋值。"
-            raise AssertionError(f"{restriction_msg}{field_info}")
-
-    return f"_validator_{grp.group_id}", \
-           validator(_field, always=True, allow_reuse=True)(_validator)
-
-
-class MetaModel(ModelMetaclass):
-    @no_type_check  # noqa C901
-    def __new__(mcs, name, bases, namespace, **kwargs):  # noqa C901
-        groups = defaultdict(dict)
-        ann = namespace.get('__annotations__', {})
-        namespace['__autofields__'] = auto_fields = {}
 
-        for k, v in namespace.items():
-            if isinstance(v, Group):
-                groups[v.group_id][k] = v
-            if isinstance(v, AutoField):
-                auto_fields[k] = ann[k]
-                ann[k] = Any
-
-        for grp in groups.values():
-            k, v = _enable_groupfield(grp)
-            namespace[k] = v
-
-        cls = super().__new__(mcs, name, bases, namespace, **kwargs)
-        return cls
+class BaseModel(PydanticBaseModel):
 
+    if Pydantic_V2:
+        model_config = ConfigDict(from_attributes=True)
 
-class BaseModel(PydanticBaseModel):
     @classmethod
     def construct_from(cls, *models: 'BaseModel', **extra):
         """
         基于PydanticBaseModel.contruct，删除不在_fields_set中的属性
         """
-        fields_set = set(cls.__fields__.keys())
         attrs = {}
-        for m in models:
-            attrs.update({
-                k: getattr(m, k)
-                for k in (m.__fields_set__ & fields_set)
-            })
+        if Pydantic_V2:
+            fields_set = set(cls.model_fields.keys())
+            for m in models:
+                attrs.update({
+                    k: getattr(m, k)
+                    for k in (m.model_fields_set & fields_set)
+                })
+        else:
+            fields_set = set(cls.__fields__.keys())
+            for m in models:
+                attrs.update({
+                    k: getattr(m, k)
+                    for k in (m.__fields_set__ & fields_set)
+                })
         attrs.update({
             k: extra[k] for
             k in (fields_set & extra.keys())
         })
-
+        if Pydantic_V2:
+            return cls.model_construct(fields_set, **attrs)
         return cls.construct(fields_set, **attrs)
 
     @classmethod
-    def quick_parse(cls, **fields):
-        # todo recursive parse dict to model
-        valid_fields = {}
-
-        for field_name, value in fields.items():
-            if field_name not in cls.__fields__:
-                continue
-
-
-class BaseModelPlus(BaseModel, metaclass=MetaModel):
-    """
-    可支持使用Group定义字段, AutoField定义字段
-
-    Examples:
-        GroupA = functools.partial(Group, group_id='aaa', at_most=2)
-        GroupB = functools.partial(Group, group_id='bbb')
-
-        class TestModel(GroupBaseModel):
-            a: str = GroupA(None, description='hello a')
-            b: str = GroupA(None, description='hello b')
-            c: int = GroupA(None, description='hello c')
-            d: int = GroupB(None, description='hello d')
-            e: int = GroupB(None, description='hello e')
-
-        按照上述定义的TestModel，在实例化时，a,b,c字段至少需提供1个，至多2个.
-        d, e字段至少提供1个，至多1个。
-        并且会在openapi中添加相应描述
-    """
-
-    def __getattribute__(self, item):
-        attr = super().__getattribute__(item)
-
-        if item.startswith('__'):
-            return attr
-        if item not in self.__autofields__:
-            return attr
-        if not isinstance(attr, str):
-            return attr
-
-        model = self.__autofields__[item]
-        new_attr = model.construct_from(**json.loads(attr))
-        setattr(self, item, new_attr)
-        return new_attr
+    def update_forward_refs(cls) -> None:
+        if Pydantic_V2:
+            return cls.model_rebuild(force=True)
+        return super().update_forward_refs()
 
     def dict(
-        self, *, include=None, exclude=None, by_alias=False, skip_defaults=None,
-        exclude_unset=False, exclude_defaults=False, exclude_none=False,
-    ):
-        ori_dict = super().dict(
-            include=include,
-            exclude=exclude,
-            skip_defaults=skip_defaults,
-            by_alias=by_alias,
-            exclude_unset=exclude_unset,
-            exclude_defaults=exclude_defaults,
-            exclude_none=exclude_none,
-        )
-        for field in self.__autofields__:
-            if not isinstance(ori := ori_dict[field], str):
-                ori_dict[field] = json.dumps(ori)
-        return ori_dict
-
-
-class HeaderModel(BaseModel):
-    app: str
-    space: str
-    user: str
-    language: str
-
-
-class Response(BaseModel):
-    status: bool = Field(description='接口状态信息')
-    code: int = Field(None, description='接口错误码')
-    message: str = Field(None, description='接口错误信息')
-    data: Any = Field(None, description='接口返回值')
-
-
-DataT = TypeVar('DataT')
-
-
-class GenericResponse(GenericModel, Generic[DataT]):
-    status: bool = Field(description='接口状态信息')
-    code: int = Field(None, description='接口错误码')
-    message: str = Field(None, description='接口错误信息')
-    data: DataT = Field(None, description='接口返回值')
-
-
-class GResponse:
-    """
-    特殊的泛型响应模型类
-    用于更好地提供响应中data字段的文档信息
-
-    Examples:
-         ``GResponse[str, description]`` 可以返回一个 GenericResponse[str] 类型，
-         并且description的内容可以展示在接口文档中。
-    """
-    memo = {}
-    data_desc = Response.__fields__['data'].field_info.description
-
-    def __class_getitem__(cls, item):
-        model_key = (cls, item)
-        if model_key in cls.memo:
-            return cls.memo[model_key]
-
-        if isinstance(item, tuple):
-            *params, description = item
-            ann = item[0]
-        else:
-            params = (item, )
-            ann = item
-            description = cls.data_desc
-
-        model_name = f"Resp{GenericModel.__concrete_name__(params)}{description}"
-
-        data_field = Field(None, description=description)
-
-        model = type(model_name, (Response,), {
-            '__annotations__': {'data': ann},
-            'data': data_field
-        })
-        cls.memo[model_key] = model
-        return model
+        self,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        if Pydantic_V2:
+            return self.model_dump(**kwargs)
+        return super().dict(**kwargs)
+
+
+def compat_parse_obj_as(cls: Type[T], data: Any) -> T:
+    if Pydantic_V2:
+        return TypeAdapter(cls).validate_python(data)
+    return parse_obj_as(cls, data)