fastapi-extra 0.3.6__tar.gz → 0.5.0__tar.gz

{fastapi_extra-0.3.6 → fastapi_extra-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-extra
-Version: 0.3.6
+Version: 0.5.0
 Summary: extra package for fastapi.
 Author-email: Ziyan Yin <408856732@qq.com>
 License: BSD-3-Clause

{fastapi_extra-0.3.6 → fastapi_extra-0.5.0}/fastapi_extra/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.3.6"
+__version__ = "0.5.0"
 
 
 from fastapi import FastAPI

fastapi_extra-0.5.0/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.3.6 → fastapi_extra-0.5.0}/fastapi_extra/database/service.py

@@ -2,13 +2,18 @@ __author__ = "ziyan.yin"
 __date__ = "2025-01-12"
 
 from contextvars import ContextVar
-from typing import Any, Generic, TypeVar
+from typing import Any, Generic, Sequence, TypeVar
+
+from sqlalchemy import ColumnExpressionArgument
+from sqlmodel import select
 
 from fastapi_extra.database.model import SQLModel
 from fastapi_extra.database.session import AsyncSession, DefaultSession
 from fastapi_extra.dependency import AbstractService
 
 Model = TypeVar("Model", bound=SQLModel)
+ID = int | str
+PK = ID | tuple[ID] | dict[str, ID]
 
 
 class ModelService(AbstractService, Generic[Model], abstract=True):
@@ -40,14 +45,24 @@ class ModelService(AbstractService, Generic[Model], abstract=True):
         assert _session is not None, "Session is not initialized"
         return _session
 
-    async def get(self, ident: int | str, **kwargs: Any) -> Model | None:
+    async def get(self, ident: PK, **kwargs: Any) -> Model | None:
         return await self.session.get(self.__model__, ident, **kwargs)
+    
+    async def get_list(self, *clause: ColumnExpressionArgument[bool] | bool) -> Sequence[Model]:
+        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)
         self.session.add(model)
         await self.session.flush()
         return model
+    
+    async def update_model(self, model: Model, **kwargs: Any) -> Model:
+        for key, value in kwargs.items():
+            if key in model.__fields__:
+                setattr(model, key, value)
+        await self.session.flush()
+        return model
 
     async def delete(self, model: Model) -> None:
         return await self.session.delete(model)

{fastapi_extra-0.3.6 → fastapi_extra-0.5.0}/fastapi_extra/response.py

@@ -223,7 +223,7 @@ class APIResponse(JSONResponse):
         
     def init_headers(self, headers: Mapping[str, str] | None = None) -> None:
         self.raw_headers = [
-            (b"content-length", str(len(self.body)).encode("latin-1")),
+            (b"content-length", f"{len(self.body)}".encode("latin-1")),
             (b"content-type", b"application/json; charset=utf-8"),
         ]
         if headers:
@@ -234,8 +234,6 @@ class APIResponse(JSONResponse):
             self.raw_headers.extend(raw_headers)
 
 
-
-
 class APIError(Exception):
     __slots__ = ("code", "message")
 

{fastapi_extra-0.3.6 → fastapi_extra-0.5.0}/fastapi_extra.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-extra
-Version: 0.3.6
+Version: 0.5.0
 Summary: extra package for fastapi.
 Author-email: Ziyan Yin <408856732@qq.com>
 License: BSD-3-Clause

fastapi_extra-0.3.6/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()}