fastapi-extra 0.4.0__tar.gz → 0.5.1__tar.gz

{fastapi_extra-0.4.0 → fastapi_extra-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-extra
-Version: 0.4.0
+Version: 0.5.1
 Summary: extra package for fastapi.
 Author-email: Ziyan Yin <408856732@qq.com>
 License: BSD-3-Clause
@@ -30,6 +30,8 @@ Provides-Extra: mysql
 Requires-Dist: asyncmy; extra == "mysql"
 Provides-Extra: pgsql
 Requires-Dist: asyncpg; extra == "pgsql"
+Provides-Extra: oracle
+Requires-Dist: python-oracledb; extra == "oracle"
 Provides-Extra: aiomysql
 Requires-Dist: aiomysql; extra == "aiomysql"
 Dynamic: license-file

{fastapi_extra-0.4.0 → fastapi_extra-0.5.1}/fastapi_extra/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.4.0"
+__version__ = "0.5.1"
 
 
 from fastapi import FastAPI

fastapi_extra-0.5.1/fastapi_extra/_patch.py

@@ -0,0 +1,172 @@
+__author__ = "ziyan.yin"
+__date__ = "2026-01-13"
+
+from typing import Any, Mapping, Sequence
+
+from fastapi import FastAPI, params
+from fastapi._compat import (ModelField, get_cached_model_fields,
+                             lenient_issubclass, shared)
+from fastapi.dependencies import utils
+from pydantic import BaseModel, Json
+from pydantic.fields import FieldInfo
+from starlette import datastructures
+
+from fastapi_extra import routing
+from fastapi_extra.urlparse import parse_qsl
+
+_ID_MAP: dict[int, bool] = {}
+_ALIAS_MAP: dict[int, str] = {}
+
+
+def install_routes(app: FastAPI) -> None:
+    routing.install(app)
+
+
+def is_sequence_field(annotation: type[Any] | None) -> bool:
+    _id = id(annotation)
+    if _id not in _ID_MAP:
+        _ID_MAP[_id] = shared.field_annotation_is_sequence(annotation)
+    return _ID_MAP[_id]
+
+
+def is_json_field(field_info: FieldInfo):
+    _id = id(field_info)
+    if _id not in _ID_MAP:
+        _ID_MAP[_id] = any(type(item) is Json for item in field_info.metadata)
+    return _ID_MAP[_id]
+
+
+def _get_multidict_value(
+    field: ModelField, 
+    values: Mapping[str, Any], 
+    alias: str,
+    is_json: bool,
+    is_sequence: bool
+) -> Any:
+    if (not is_json) and is_sequence and hasattr(values, "getlist"):
+        value = values.getlist(alias) # pyright: ignore[reportAttributeAccessIssue]
+    else:
+        value = values.get(alias, None)
+
+    if (
+        (
+            value == ""
+            and isinstance(field.field_info, params.Form)
+        )
+        or (
+            is_sequence
+            and len(value) == 0
+        )
+    ):
+        return None
+
+    return value
+
+
+def request_params_to_args(
+    fields: Sequence[ModelField],
+    received_params: Mapping[str, Any] | datastructures.QueryParams | datastructures.Headers,
+) -> tuple[dict[str, Any], list[Any]]:
+    values: dict[str, Any] = {}
+    errors: list[dict[str, Any]] = []
+
+    if not fields:
+        return values, errors
+
+    first_field = fields[0]
+    
+    is_multidict = hasattr(received_params, "getlist")
+    is_headers = isinstance(received_params, datastructures.Headers)
+
+    # =========================================================================
+    # 分支 A：单模型解析 (例如使用 Pydantic 接收整个 Query 或是 Header 结构)
+    # =========================================================================
+    if len(fields) == 1 and lenient_issubclass(
+        first_field.field_info.annotation, BaseModel
+    ):
+        fields_to_extract = get_cached_model_fields(first_field.field_info.annotation)
+        default_convert_underscores = getattr(
+            first_field.field_info, "convert_underscores", True
+        )
+        
+        params_to_process: dict[str, Any] = {}
+        processed_keys = set()
+
+        for field in fields_to_extract:
+            field_alias = utils.get_validation_alias(field)
+            alias = field_alias
+            
+            if is_headers:
+                convert_underscores = getattr(
+                    field.field_info, "convert_underscores", default_convert_underscores
+                )
+                if convert_underscores and alias == field.name:
+                    alias = alias.replace("_", "-")
+            
+            # 提前准备属性判断
+            is_json = is_json_field(field.field_info)
+            is_sequence = is_sequence_field(field.field_info.annotation)
+
+            value = _get_multidict_value(
+                field, received_params, alias=alias, is_json=is_json, is_sequence=is_sequence
+            )
+            if value is not None:
+                params_to_process[field_alias] = value
+            processed_keys.add(alias)
+
+        # 补全未在模型中显式定义的其他传入参数
+        for key in received_params.keys():
+            if key not in processed_keys:
+                if is_multidict:
+                    value = received_params.getlist(key)  # type: ignore
+                    params_to_process[key] = value[0] if isinstance(value, list) and len(value) == 1 else value
+                else:
+                    params_to_process[key] = received_params.get(key)
+
+        field_info = first_field.field_info
+        assert isinstance(field_info, params.Param), "Params must be subclasses of Param"   
+        
+        v_, errors_ = first_field.validate(params_to_process, values, loc=(field_info.in_.value,))
+        return {first_field.name: v_}, errors_
+
+    # =========================================================================
+    # 分支 B：多参数平铺解析 (Fast Path - 大部分常规路由走这里)
+    # =========================================================================
+    else:
+        for field in fields:
+            field_alias = utils.get_validation_alias(field)
+            field_info = field.field_info
+            
+            # 属性判断预提取与缓存
+            is_json = is_json_field(field_info)
+            is_sequence = is_sequence_field(field_info.annotation)
+
+            value = _get_multidict_value(
+                field, received_params, alias=field_alias, is_json=is_json, is_sequence=is_sequence
+            )
+            
+            assert isinstance(field_info, params.Param), "Params must be subclasses of Param"
+            loc = (field_info.in_.value, field_alias)
+            
+            v_, errors_ = utils._validate_value_with_model_field(
+                field=field, value=value, values=values, loc=loc
+            )
+            if errors_:
+                errors.extend(errors_)
+            else:
+                values[field.name] = v_
+                
+        return values, errors
+
+
+def query_params_init(obj: datastructures.QueryParams, *args, **kwargs) -> None:
+    value = args[0] if args else []
+
+    if isinstance(value, bytes):
+        super(datastructures.QueryParams, obj).__init__(parse_qsl(value, keep_blank_values=True), **kwargs)
+    elif isinstance(value, str):
+        super(datastructures.QueryParams, obj).__init__(parse_qsl(value.encode("latin-1"), keep_blank_values=True), **kwargs)
+    else:
+        super(datastructures.QueryParams, obj).__init__(*args, **kwargs)  # type: ignore[arg-type]
+        obj._list = [(str(k), str(v)) for k, v in obj._list]
+        obj._dict = {str(k): str(v) for k, v in obj._dict.items()}

{fastapi_extra-0.4.0 → fastapi_extra-0.5.1}/fastapi_extra/database/model.py

@@ -14,7 +14,7 @@ from fastapi_extra.utils import get_machine_seed
 
 
 class AutoPK(SQLModel):
-    id: int | None = Field(
+    id: int = Field(
         default=None,
         title="ID",
         primary_key=True,
@@ -25,7 +25,7 @@ class AutoPK(SQLModel):
 
 
 class LocalPK(SQLModel):
-    id: Cursor | None = Field(
+    id: Cursor = Field(
         default_factory=_Cursor(get_machine_seed()).next_val,
         title="ID",
         primary_key=True,

{fastapi_extra-0.4.0 → fastapi_extra-0.5.1}/fastapi_extra/database/service.py

@@ -1,9 +1,11 @@
 __author__ = "ziyan.yin"
 __date__ = "2025-01-12"
 
+
 from contextvars import ContextVar
 from typing import Any, Generic, Sequence, TypeVar
 
+import anyio.to_thread
 from sqlalchemy import ColumnExpressionArgument
 from sqlmodel import select
 
@@ -52,15 +54,18 @@ class ModelService(AbstractService, Generic[Model], abstract=True):
         return (await self.session.exec(select(self.__model__).where(*clause))).all()
 
     async def create_model(self, **kwargs: Any) -> Model:
-        model = self.__model__.model_validate(kwargs)
+        model = await anyio.to_thread.run_sync(self.__model__.model_validate, kwargs)
         self.session.add(model)
         await self.session.flush()
         return model
     
-    async def update_model(self, model: Model, **kwargs: Any) -> Model:
+    async def update_model(self, model: Model, _ignore_none: bool = False, **kwargs: Any) -> Model:
         for key, value in kwargs.items():
-            if key in model.__fields__:
-                setattr(model, key, value)
+            if key not in model.__fields__:
+                continue
+            if _ignore_none and value is None:
+                continue
+            setattr(model, key, value)
         await self.session.flush()
         return model
 

{fastapi_extra-0.4.0 → fastapi_extra-0.5.1}/fastapi_extra/response.py

@@ -3,7 +3,8 @@ __date__ = "2024-12-24"
 
 
 from enum import Enum
-from typing import TYPE_CHECKING, Generic, Mapping
+from typing import (TYPE_CHECKING, Generic, Mapping, NotRequired, TypedDict,
+                    Unpack)
 
 from fastapi.responses import JSONResponse
 from pydantic import BaseModel, Field
@@ -191,22 +192,25 @@ class ResultEnum(Enum):
     C0503 = ("C0503", "邮件提醒服务失败")
 
 
+class ResponseKwargs(TypedDict):
+    status_code: NotRequired[int]
+    headers: NotRequired[Mapping[str, str] | None]
+
+
 class APIResult(BaseModel, Generic[T]):
     data: T | None = Field(default=None, title="返回数据")
 
     if TYPE_CHECKING:
-
         @classmethod
-        def ok(cls, data: T | None = None) -> "APIResult[T]":
+        def ok(cls, data: T | None = None, **response_kwargs: Unpack[ResponseKwargs]) -> "APIResult[T]":
             return APIResult(data=data)
 
     else:
-
         @classmethod
-        def ok(cls, data: T | None = None) -> "APIResponse":
+        def ok(cls, data: T | None = None, status_code: int = 200, headers: Mapping[str, str] | None = None) -> "APIResponse":
             model = cls.__new__(cls)
             model.__dict__["data"] = data
-            return APIResponse(model)
+            return APIResponse(model, status_code=status_code, headers=headers)
 
 
 class APIResponse(JSONResponse):

{fastapi_extra-0.4.0 → fastapi_extra-0.5.1}/fastapi_extra.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-extra
-Version: 0.4.0
+Version: 0.5.1
 Summary: extra package for fastapi.
 Author-email: Ziyan Yin <408856732@qq.com>
 License: BSD-3-Clause
@@ -30,6 +30,8 @@ Provides-Extra: mysql
 Requires-Dist: asyncmy; extra == "mysql"
 Provides-Extra: pgsql
 Requires-Dist: asyncpg; extra == "pgsql"
+Provides-Extra: oracle
+Requires-Dist: python-oracledb; extra == "oracle"
 Provides-Extra: aiomysql
 Requires-Dist: aiomysql; extra == "aiomysql"
 Dynamic: license-file

{fastapi_extra-0.4.0 → fastapi_extra-0.5.1}/fastapi_extra.egg-info/requires.txt

@@ -9,6 +9,9 @@ aiomysql
 [mysql]
 asyncmy
 
+[oracle]
+python-oracledb
+
 [pgsql]
 asyncpg
 

{fastapi_extra-0.4.0 → fastapi_extra-0.5.1}/pyproject.toml

@@ -41,6 +41,7 @@ redis = ["redis"]
 scheduler = ["apscheduler"]
 mysql = ["asyncmy"]
 pgsql = ["asyncpg"]
+oracle = ["python-oracledb"]
 aiomysql = ["aiomysql"]
 
 [tool.setuptools]

fastapi_extra-0.4.0/fastapi_extra/_patch.py

@@ -1,121 +0,0 @@
-__author__ = "ziyan.yin"
-__date__ = "2026-01-13"
-
-import functools
-from typing import Any, Mapping, Sequence, Union
-
-from fastapi import FastAPI, params
-from fastapi._compat import (ModelField, get_cached_model_fields,
-                             lenient_issubclass, shared)
-from fastapi.dependencies import utils
-from pydantic import BaseModel
-from starlette import datastructures
-
-from fastapi_extra import routing
-from fastapi_extra.urlparse import parse_qsl
-
-
-def install_routes(app: FastAPI) -> None:
-    routing.install(app)
-
-
-@functools.lru_cache
-def is_sequence_field(annotation: type[Any]) -> bool:
-    return shared.field_annotation_is_sequence(annotation)
-
-
-def request_params_to_args(
-    fields: Sequence[ModelField],
-    received_params: Union[Mapping[str, Any], datastructures.QueryParams, datastructures.Headers],
-) -> tuple[dict[str, Any], list[Any]]:
-    values: dict[str, Any] = {}
-    errors: list[dict[str, Any]] = []
-
-    if not fields:
-        return values, errors
-
-    first_field = fields[0]
-    fields_to_extract = fields
-    single_not_embedded_field = False
-    default_convert_underscores = True
-    if len(fields) == 1 and lenient_issubclass(
-        first_field.field_info.annotation, BaseModel
-    ):
-        fields_to_extract = get_cached_model_fields(first_field.field_info.annotation)
-        single_not_embedded_field = True
-        # If headers are in a Pydantic model, the way to disable convert_underscores
-        # would be with Header(convert_underscores=False) at the Pydantic model level
-        default_convert_underscores = getattr(
-            first_field.field_info, "convert_underscores", True
-        )
-
-    params_to_process: dict[str, Any] = {}
-
-    processed_keys = set()
-
-    for field in fields_to_extract:
-        alias = field_alias = utils.get_validation_alias(field)
-        if isinstance(received_params, datastructures.Headers):
-            # Handle fields extracted from a Pydantic Model for a header, each field
-            # doesn't have a FieldInfo of type Header with the default convert_underscores=True
-            convert_underscores = getattr(
-                field.field_info, "convert_underscores", default_convert_underscores
-            )
-            if convert_underscores and alias == field.name:
-                alias = alias.replace("_", "-")
-        value = utils._get_multidict_value(field, received_params, alias=alias)
-        if value is not None:
-            params_to_process[field_alias] = value
-        processed_keys.add(alias)
-
-    for key in received_params.keys():
-        if key not in processed_keys:
-            if hasattr(received_params, "getlist"):
-                value = received_params.getlist(key) # type: ignore
-                if isinstance(value, list) and (len(value) == 1):
-                    params_to_process[key] = value[0]
-                else:
-                    params_to_process[key] = value
-            else:
-                params_to_process[key] = received_params.get(key)
-
-    if single_not_embedded_field:
-        field_info = first_field.field_info
-        assert isinstance(field_info, params.Param), (
-            "Params must be subclasses of Param"
-        )
-        loc: tuple[str, ...] = (field_info.in_.value,)
-        v_, errors_ = utils._validate_value_with_model_field(
-            field=first_field, value=params_to_process, values=values, loc=loc
-        )
-        return {first_field.name: v_}, errors_
-
-    for field in fields:
-        field_alias = utils.get_validation_alias(field)
-        value = params_to_process.get(field_alias, None)
-        field_info = field.field_info
-        assert isinstance(field_info, params.Param), (
-            "Params must be subclasses of Param"
-        )
-        loc = (field_info.in_.value, field_alias)
-        v_, errors_ = utils._validate_value_with_model_field(
-            field=field, value=value, values=values, loc=loc
-        )
-        if errors_:
-            errors.extend(errors_)
-        else:
-            values[field.name] = v_
-    return values, errors
-
-
-def query_params_init(obj: datastructures.QueryParams, *args, **kwargs) -> None:
-    value = args[0] if args else []
-
-    if isinstance(value, bytes):
-        super(datastructures.QueryParams, obj).__init__(parse_qsl(value, keep_blank_values=True), **kwargs)
-    elif isinstance(value, str):
-        super(datastructures.QueryParams, obj).__init__(parse_qsl(value.encode("latin-1"), keep_blank_values=True), **kwargs)
-    else:
-        super(datastructures.QueryParams, obj).__init__(*args, **kwargs)  # type: ignore[arg-type]
-        obj._list = [(str(k), str(v)) for k, v in obj._list]
-        obj._dict = {str(k): str(v) for k, v in obj._dict.items()}