libentry 1.11.12__py3-none-any.whl → 1.12__py3-none-any.whl

libentry/schema.py

@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+
+__author__ = "xi"
+__all__ = [
+    "SchemaField",
+    "Schema",
+    "ParseContext",
+    "parse_type",
+    "QueryAPIOutput",
+    "query_api",
+]
+
+import enum
+from dataclasses import dataclass
+from inspect import signature
+from typing import Any, Iterable, List, Literal, Mapping, MutableMapping, NoReturn, Optional, Sequence, Union, get_args, \
+    get_origin
+
+from pydantic import BaseModel, Field, create_model
+from pydantic_core import PydanticUndefined
+
+
+class SchemaField(BaseModel):
+    name: str = Field()
+    type: Union[str, List[str]] = Field("Any")
+    default: Any = Field()
+    is_required: bool = Field(True)
+    title: str = Field()
+    description: Optional[str] = Field(None)
+
+
+class Schema(BaseModel):
+    name: str = Field()
+    fields: List[SchemaField] = Field(default_factory=list)
+
+
+@dataclass
+class ParseContext:
+    annotation: Any
+    schemas: MutableMapping[str, Schema]
+    origin: Any
+
+
+_TYPE_PARSERS = []
+_GENERIC_PARSERS = []
+
+
+def parse_type(annotation, context: MutableMapping[str, Schema]) -> Union[str, List[str]]:
+    origin = get_origin(annotation)
+    if origin is None:
+        origin = annotation
+    pc = ParseContext(
+        annotation=annotation,
+        schemas=context,
+        origin=origin
+    )
+
+    parser_list = _TYPE_PARSERS if isinstance(origin, type) else _GENERIC_PARSERS
+    for parser in parser_list:
+        output = parser(pc)
+        if output is not None:
+            return output
+    raise TypeError(f"Unsupported type \"{origin}\".")
+
+
+def type_parser(fn):
+    _TYPE_PARSERS.append(fn)
+    return fn
+
+
+@type_parser
+def _parse_basic_types(context: ParseContext):
+    if context.origin in {int, float, str, bool}:
+        return context.origin.__name__
+
+
+@type_parser
+def _parse_dict(context: ParseContext):
+    if issubclass(context.origin, Mapping):
+        dict_args = get_args(context.annotation)
+        if dict_args:
+            key_type = dict_args[0]
+            if key_type is not str:
+                raise TypeError("Only \"str\" can be used as the type of dict keys.")
+            key_type = "str"
+            value_type = parse_type(dict_args[1], context.schemas)
+            if isinstance(value_type, list):
+                raise TypeError("\"Union\" cannot be used as the type of list elements.")
+            return f"Dict[{key_type},{value_type}]"
+        else:
+            return "Dict"
+
+
+@type_parser
+def _parse_list(context: ParseContext):
+    if issubclass(context.origin, Sequence):
+        list_args = get_args(context.annotation)
+        if list_args:
+            if len(list_args) > 1:
+                raise TypeError("Only ONE type can be used as the type of list elements.")
+            elem_type = parse_type(list_args[0], context.schemas)
+            if isinstance(elem_type, list):
+                raise TypeError("\"Union\" cannot be used as the type of list elements.")
+            return f"List[{elem_type}]"
+        else:
+            return "List"
+
+
+@type_parser
+def _parse_enum(context: ParseContext):
+    if issubclass(context.origin, enum.Enum):
+        return f"Enum[{','.join(e.name for e in context.origin)}]"
+
+
+@type_parser
+def _parse_base_model(context: ParseContext):
+    origin = context.origin
+    if issubclass(origin, BaseModel):
+        _module = origin.__module__
+        _name = origin.__name__
+        model_name = _name if (_module is None) else f"{_module}.{_name}"
+
+        is_new_model = model_name not in context.schemas
+        is_not_base_class = origin is not BaseModel
+        if is_new_model and is_not_base_class:
+            schema = Schema(name=model_name)
+            fields = origin.model_fields
+            assert isinstance(fields, Mapping)
+            for name, field in fields.items():
+
+                try:
+                    schema.fields.append(SchemaField(
+                        name=name,
+                        type=parse_type(field.annotation, context.schemas),
+                        default=field.default if field.default is not PydanticUndefined else None,
+                        is_required=field.is_required(),
+                        title="".join(word.capitalize() for word in name.split("_")),
+                        description=field.description
+                    ))
+                except TypeError as e:
+                    raise TypeError(f"{name}: {str(e)}")
+            context.schemas[model_name] = schema
+
+        return model_name
+
+
+@type_parser
+def _parse_iterable(context: ParseContext):
+    if context.origin.__name__ in {"Iterable", "Generator", "range"} and issubclass(context.origin, Iterable):
+        iter_args = get_args(context.annotation)
+        if len(iter_args) != 1:
+            raise TypeError("Only ONE type can be used as the type of iterable elements.")
+        iter_type = parse_type(iter_args[0], context.schemas)
+        if isinstance(iter_type, list):
+            raise TypeError("\"Union\" cannot be used as the type of iterable elements.")
+        return f"Iter[{iter_type}]"
+
+
+@type_parser
+def _parse_none_type(context: ParseContext):
+    origin = context.origin
+    if origin.__module__ == "builtins" and origin.__name__ == "NoneType":
+        return "NoneType"
+
+
+@type_parser
+def _parse_ndarray(context: ParseContext):
+    origin = context.origin
+    if origin.__module__ == "numpy" and origin.__name__ == "ndarray":
+        return "numpy.ndarray"
+
+
+def generic_parser(fn):
+    _GENERIC_PARSERS.append(fn)
+    return fn
+
+
+@generic_parser
+def _parse_any(context: ParseContext):
+    if context.origin is Any:
+        return "Any"
+
+
+@generic_parser
+def _parse_union(context: ParseContext):
+    if context.origin is Union:
+        return [
+            parse_type(arg, context.schemas)
+            for arg in get_args(context.annotation)
+        ]
+
+
+@generic_parser
+def _parse_literal(context: ParseContext):
+    if context.origin is Literal:
+        enum_args = get_args(context.annotation)
+        return f"Enum[{','.join(map(str, enum_args))}]"
+
+
+class QueryAPIOutput(BaseModel):
+    input_schema: str
+    output_schema: str
+    context: Mapping[str, Schema]
+    bundled_input: bool
+
+
+def query_api(fn) -> QueryAPIOutput:
+    sig = signature(fn)
+
+    fields = {}
+    for name, param in sig.parameters.items():
+        if name in ["self", "cls"]:
+            continue
+
+        annotation = param.annotation
+        if annotation is sig.empty:
+            annotation = Any
+
+        default = param.default
+        field = Field() if default is sig.empty else Field(default)
+        fields[name] = (annotation, field)
+
+    args_model = None
+    if len(fields) == 1:
+        for annotation, _ in fields.values():
+            origin = get_origin(annotation)
+            if origin is None:
+                origin = annotation
+            if isinstance(origin, type) and issubclass(origin, BaseModel):
+                args_model = origin
+    bundle = args_model is None
+    if bundle:
+        name = "".join(word.capitalize() for word in fn.__name__.split("_"))
+        args_model = create_model(f"{name}Request*", **fields)
+
+    context = {}
+    input_schema = parse_type(args_model, context)
+    output_schema = None
+    return_annotation = sig.return_annotation
+    if return_annotation is not None and return_annotation is not NoReturn:
+        if return_annotation is sig.empty:
+            return_annotation = Any
+        output_schema = parse_type(return_annotation, context)
+    if isinstance(output_schema, list):
+        output_schema = output_schema[0]
+
+    return QueryAPIOutput(
+        input_schema=input_schema,
+        output_schema=output_schema,
+        context=context,
+        bundled_input=bundle,
+    )

libentry/service/flask.py

@@ -15,11 +15,11 @@ from typing import Any, Callable, Iterable, Optional, Type, Union
 from flask import Flask, request
 from gunicorn.app.base import BaseApplication
 from pydantic import BaseModel, Field, create_model
-from pydantic.json_schema import GenerateJsonSchema
 
 from libentry import api, json
 from libentry.api import APIInfo, list_api_info
 from libentry.logging import logger
+from libentry.schema import query_api
 
 
 class JSONDumper:
@@ -222,14 +222,6 @@ class FlaskWrapper:
                 )
 
 
-class CustomGenerateJsonSchema(GenerateJsonSchema):
-
-    def handle_invalid_for_json_schema(self, schema, error_info: str):
-        cls = schema.get("cls")
-        cls_name = f"{cls.__module__}.{cls.__name__}" if cls is not None else "UNKNOWN"
-        return {"type": cls_name}
-
-
 class FlaskServer(Flask):
 
     def __init__(self, service):
@@ -286,10 +278,7 @@ class FlaskServer(Flask):
 
         for fn, api_info in self.api_info_list:
             if api_info.path == "/" + name:
-                # noinspection PyTypeChecker
-                dynamic_model = create_model_from_signature(fn)
-                schema = dynamic_model.model_json_schema(schema_generator=CustomGenerateJsonSchema)
-                return schema
+                return query_api(fn).model_dump()
 
         return f"No API named \"{name}\""
 

{libentry-1.11.12.dist-info → libentry-1.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: libentry
-Version: 1.11.12
+Version: 1.12
 Summary: Entries for experimental utilities.
 Home-page: https://github.com/XoriieInpottn/libentry
 Author: xi

{libentry-1.11.12.dist-info → libentry-1.12.dist-info}/RECORD

@@ -6,17 +6,18 @@ libentry/executor.py,sha256=cTV0WxJi0nU1TP-cOwmeodN8DD6L1691M2HIQsJtGrU,6582
 libentry/experiment.py,sha256=ejgAHDXWIe9x4haUzIFuz1WasLY0_aD1z_vyEVGjTu8,4922
 libentry/json.py,sha256=1-Kv5ZRb5dBrOTU84n6sZtYZV3xE-O6wEt_--ynbSaU,1209
 libentry/logging.py,sha256=IiYoCUzm8XTK1fduA-NA0FI2Qz_m81NEPV3d3tEfgdI,1349
+libentry/schema.py,sha256=ZlQnqUrL0YQ5koZnka7RNfOSzaH5llQ5XhQI6ig02xk,7629
 libentry/server.py,sha256=gYPoZXd0umlDYZf-6ZV0_vJadg3YQvnLDc6JFDJh9jc,1503
 libentry/service/__init__.py,sha256=1oLL20yLB1GL9IbFiZD8OReDqiCpFr-yetIR6x1cNkI,23
 libentry/service/common.py,sha256=OVaW2afgKA6YqstJmtnprBCqQEUZEWotZ6tHavmJJeU,42
-libentry/service/flask.py,sha256=IWA9GKyuLCcdpuwZxjKXMOy8MCnEWympMyNjHxRXu-Q,12333
+libentry/service/flask.py,sha256=3fTkysQkCZ-flVH7FKWnOiMNmdkGb7kJGmmz1PZqkPE,11850
 libentry/service/list.py,sha256=ElHWhTgShGOhaxMUEwVbMXos0NQKjHsODboiQ-3AMwE,1397
 libentry/service/running.py,sha256=FrPJoJX6wYxcHIysoatAxhW3LajCCm0Gx6l7__6sULQ,5105
 libentry/service/start.py,sha256=mZT7b9rVULvzy9GTZwxWnciCHgv9dbGN2JbxM60OMn4,1270
 libentry/service/stop.py,sha256=wOpwZgrEJ7QirntfvibGq-XsTC6b3ELhzRW2zezh-0s,1187
-libentry-1.11.12.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-libentry-1.11.12.dist-info/METADATA,sha256=GLIiUoxHfO_byVbTFbyBMar-S8ywTkGzZR_tQpRBmII,794
-libentry-1.11.12.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-libentry-1.11.12.dist-info/top_level.txt,sha256=u2uF6-X5fn2Erf9PYXOg_6tntPqTpyT-yzUZrltEd6I,9
-libentry-1.11.12.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-libentry-1.11.12.dist-info/RECORD,,
+libentry-1.12.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+libentry-1.12.dist-info/METADATA,sha256=42N3OAb8OEdO_DsYaIQgYzC9fvZGTsTzuqj7G-YY69k,791
+libentry-1.12.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+libentry-1.12.dist-info/top_level.txt,sha256=u2uF6-X5fn2Erf9PYXOg_6tntPqTpyT-yzUZrltEd6I,9
+libentry-1.12.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+libentry-1.12.dist-info/RECORD,,