querymodelling 0.0.1__tar.gz → 0.0.2a0__tar.gz

{querymodelling-0.0.1/querymodelling.egg-info → querymodelling-0.0.2a0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: querymodelling
-Version: 0.0.1
+Version: 0.0.2a0
 Summary: build consistent api query models for fastapi
 Author: George Haddad
 Author-email: George Haddad <georgeh87@live.de>
@@ -215,3 +215,11 @@ Dynamic: author
 
 # querymodelling
 build consistent api query models for fastapi
+
+## Requirements
+At least you will need to have the pydantic package installed. Of course it make sense to have some kind of service supporting query models like fast api. Currently sql models are implemented - but feel free to create new ones.
+
+## Installation
+
+## Example
+

querymodelling-0.0.2a0/README.md

@@ -0,0 +1,10 @@
+# querymodelling
+build consistent api query models for fastapi
+
+## Requirements
+At least you will need to have the pydantic package installed. Of course it make sense to have some kind of service supporting query models like fast api. Currently sql models are implemented - but feel free to create new ones.
+
+## Installation
+
+## Example
+

{querymodelling-0.0.1 → querymodelling-0.0.2a0}/pyproject.toml

@@ -11,7 +11,7 @@ testpaths = ["tests"]
 
 [project]
 name = "querymodelling"
-version = "0.0.1"
+version = "0.0.2a"
 description = "build consistent api query models for fastapi"
 readme = "README.md"
 requires-python = ">=3.11"

{querymodelling-0.0.1 → querymodelling-0.0.2a0}/querymodelling/__version__.py

@@ -1,7 +1,7 @@
 __title__ = "querymodelling"
 __description__ = ""
 __url__ = "https://querymodelling.readthedocs.io"
-__version__ = "0.0.1"
+__version__ = "0.0.2a"
 __build__ = 0x023100
 __author__ = "George Haddad"
 __author_email__ = "georgeh87@live.de"

{querymodelling-0.0.1 → querymodelling-0.0.2a0}/querymodelling/base.py

@@ -1,7 +1,8 @@
 from pydantic import BaseModel, create_model, Field
 from pydantic.fields import FieldInfo
 from typing import (
-    TypeVar, Literal, Type, Callable, Dict, Tuple, Any, get_origin, Optional, Union, get_args, Generic, ParamSpecArgs, TypeVarTuple, Unpack, Self
+    TypeVar, Literal, Type, Callable, Dict, Tuple, Any, get_origin, Optional,
+    Union, get_args, Generator
 )
 
 from .model import PageQuery
@@ -21,7 +22,7 @@ def get_functions(model: BaseModel, function_type: str):
             queries.append(function(getattr(model, name)))
     return queries
 
-A = TypeVar("A", )
+A = TypeVar("A")
 
 def optional_fields(
     base_model: BaseModel,
@@ -47,10 +48,8 @@ def optional_fields(
     return fields
 
 T = TypeVar("T", bound=BaseModel)
-Ts = TypeVarTuple("Ts")
 C = TypeVar("C", bound=Union[PageQuery, BaseModel])
 
-
 def parse_field(input_field: FieldInfo) -> FieldInfo:
     data = {
         key: getattr(input_field, key)
@@ -61,21 +60,36 @@ def parse_field(input_field: FieldInfo) -> FieldInfo:
     return Field(**data)
 
 def AutoQueryModel(
-    base_models: Type[A] | list[Type[A]],
+    base_models: Type[T] | list[Type[T]],
     base_query_models: Type[C] | list[Type[C]],
-    callback: Callable[[type, str, any, FieldInfo], FieldInfo],
+    callback: Callable[
+        [type, str, any, FieldInfo],
+        Generator[Tuple[Type, str, Any, FieldInfo, Any], None, None]
+    ],
     exclude_fields: list[str] = None,
     include_fields: list[str] = None
 ) -> Type[A]:
-    """_summary_
-
-    :param base_models: _description_
+    """Automatic generates a query model based on the fields of the base query 
+    models. The newly generated model will have the same fields as the base 
+    query models, but with the option to modify the fields using the callback 
+    function or using the exclude- and include- fields parameters. The 
+    callback function will be called for each field of the base query models 
+    and should return a tuple with the field name, the field info and the 
+    annotation of the field. The exclude- and include- fields parameters can 
+    be used to exclude or include specific fields from the base query models. 
+    On the other hand the newly generated model will inherit from the defined 
+    base models.
+
+    :param base_models: The base models to inherit from.
     :type base_models: Type[A] | list[Type[A]]
-    :param base_query_models: _description_
+    :param base_query_models: The base query models to generate the query 
+        model from.
     :type base_query_models: Type[C] | list[Type[C]]
-    :param callback: _description_
-    :type callback: Callable[[type, str, any, FieldInfo], FieldInfo]
-    :param exclude_fields: _description_, defaults to None
+    :param callback: The callback function to modify the fields of the base
+        query models.
+    :type callback: Callable[[type, str, any, FieldInfo], 
+        Generator[Tuple[Type, str, Any, FieldInfo, Any], None, None]]
+    :param exclude_fields: , defaults to None
     :type exclude_fields: list[str], optional
     :param include_fields: _description_, defaults to None
     :type include_fields: list[str], optional
@@ -121,4 +135,4 @@ def AutoQueryModel(
     )
     return model
 
-DefaultSort = Literal["asc", "desc"]
+DefaultSort = Literal["asc", "desc"]

{querymodelling-0.0.1 → querymodelling-0.0.2a0}/querymodelling/fields.py

@@ -5,18 +5,21 @@ from typing import TypeVar, ParamSpec, Callable, Concatenate
 T = TypeVar("T", bound=BaseModel)
 PK = ParamSpec("PK")
 
-
 def Field(BaseField: Callable[PK, T]):
     def field_wrapper(
         *args,
         query_function = None,
         sort_function = None,
         query_type: str = None,
+        json_schema_extra: dict = None,
         **kwargs
     ):
         field_info = BaseField(
             *args,
             query_type=query_type,
+            json_schema_extra=(json_schema_extra or {}) | {
+                "query.type": query_type
+            },
             **kwargs,
         )
         if query_function:
@@ -24,7 +27,6 @@ def Field(BaseField: Callable[PK, T]):
         if sort_function:
             field_info.metadata.append(("sort_function", sort_function))
         return field_info
-        
     return field_wrapper
 
 def QueryField(BaseField: Callable[PK, T]) -> Callable[

{querymodelling-0.0.1 → querymodelling-0.0.2a0}/querymodelling/model.py

@@ -11,4 +11,3 @@ class PageQuery:
     @property
     def offset_end(self):
         return self.offset + self.size
-    

{querymodelling-0.0.1 → querymodelling-0.0.2a0}/querymodelling/pydantic.py

@@ -2,10 +2,7 @@ from pydantic import Field
 
 from .fields import QueryField as BaseQueryField
 from .fields import SortField as BaseSortField
-from .sql import ExtendedTextSearch as BaseExtendedSqlTextSearch
 
 
 QueryField = BaseQueryField(Field)
 SortField = BaseSortField(Field)
-
-ExtendedSqlTextSearch = BaseExtendedSqlTextSearch(Field)

querymodelling-0.0.2a0/querymodelling/sql.py

@@ -0,0 +1,143 @@
+from datetime import datetime
+from sqlmodel import Session, select, func
+from sqlalchemy.orm.attributes import InstrumentedAttribute
+from typing import TypeVar, Sequence, Type, Callable, ParamSpec
+from pydantic import AliasChoices
+
+from .base import get_functions, DefaultSort
+from .fields import QueryField, SortField
+from .model import PageQuery
+
+
+T = TypeVar("T")
+PK = ParamSpec("PK")
+Q = TypeVar("Q", bound=PageQuery)
+
+def sortable_by(field):
+    def wrapper(order: DefaultSort):
+        if order == "desc":
+            return field.desc()
+        if order == "asc":
+            return field.asc()
+    return wrapper
+
+def retrieve_entries(
+    query: Q,
+    session: Session,
+    t: Type[T],
+    t_index: InstrumentedAttribute
+) -> tuple[int, Sequence[T]]:
+    search_clause = get_functions(query, "query")
+    order_clause = get_functions(query, "sort")
+    total_elements = session.exec(select(func.count()).where(
+        *search_clause).select_from(t)).first()
+
+    sub_statement = select(t_index)
+    if search_clause:
+        sub_statement = sub_statement.where(*search_clause)
+    if order_clause:
+        sub_statement = sub_statement.order_by(*order_clause)
+    sub_statement = sub_statement.limit(query.size).offset(
+        query.page * query.size)
+    sub_query = sub_statement.subquery()
+    sub_query_id = sub_query.c.__getattr__(t_index.key)
+
+    statement = select(t).join(
+        sub_query, t_index == sub_query_id)
+
+    return total_elements, session.exec(statement).all()
+
+def create_query_fields(
+    base_field: any,
+    field_name: str,
+    annotation: any,
+    operator_mapping: dict[str, Callable],
+    json_schema_extra: dict
+):   
+    for operator, operator_function in operator_mapping.items():
+        validation_alias = None
+        alias = None
+        if operator is None:
+            name = field_name
+        else:
+            name = f"{field_name}_{operator}"
+            alias = f"{field_name}.{operator}"
+            validation_alias = AliasChoices(name, alias)
+        yield (
+            name,
+            QueryField(base_field)(
+                operator_function,
+                alias=alias,
+                validation_alias=validation_alias,
+                default=None,
+                json_schema_extra=json_schema_extra | {
+                    "query.backend": "sql",
+                    "query.operator": operator
+                }
+            ),
+            annotation
+        )
+
+def create_callback(
+    base_field,
+    copy_field_properties: list[str] = None,
+    schema_extra: dict = None
+):
+    def auto_create_callback(
+        source_type: type,
+        field_name: str,
+        field,
+        field_info,
+        annotation
+    ):
+        if copy_field_properties is None and schema_extra is None:
+            json_schema_extra = field_info.json_schema_extra
+        json_schema_extra = schema_extra or {}
+        if copy_field_properties is not None:
+            for property_name in copy_field_properties:
+                json_schema_extra[property_name] = field_info[
+                    property_name]
+
+        if annotation == str:
+            operator_mapping = {
+                None: lambda value: field == value,
+                "startswith": lambda value: field.like(f"{value}%"),
+                "endswith": lambda value: field.like(f"%{value}"),
+                "contains": lambda value: field.like(f"%{value}%")
+            }
+            yield from create_query_fields(
+                base_field,
+                field_name,
+                annotation,
+                operator_mapping,
+                json_schema_extra
+            )
+        elif annotation in (datetime, int):
+            operator_mapping = {
+                None: lambda value: field == value,
+                "from": lambda value: field >= value,
+                "to": lambda value: field <= value
+            }
+            yield from create_query_fields(
+                base_field,
+                field_name,
+                annotation,
+                operator_mapping,
+                json_schema_extra
+            ) 
+        sort_name = f"sort_{field_name}"
+        sort_name_dot = f"sort.{field_name}"
+        yield (
+            sort_name_dot,
+            SortField(base_field)(
+                sortable_by(source_type.__dict__[field_name]),
+                alias=sort_name_dot,
+                validation_alias=AliasChoices(sort_name, sort_name_dot),
+                default=None,
+                json_schema_extra=json_schema_extra | {
+                    "query.backend": "sql"
+                }
+            ),
+            DefaultSort
+        )
+    return auto_create_callback

{querymodelling-0.0.1 → querymodelling-0.0.2a0/querymodelling.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: querymodelling
-Version: 0.0.1
+Version: 0.0.2a0
 Summary: build consistent api query models for fastapi
 Author: George Haddad
 Author-email: George Haddad <georgeh87@live.de>
@@ -215,3 +215,11 @@ Dynamic: author
 
 # querymodelling
 build consistent api query models for fastapi
+
+## Requirements
+At least you will need to have the pydantic package installed. Of course it make sense to have some kind of service supporting query models like fast api. Currently sql models are implemented - but feel free to create new ones.
+
+## Installation
+
+## Example
+

querymodelling-0.0.1/README.md

@@ -1,2 +0,0 @@
-# querymodelling
-build consistent api query models for fastapi

querymodelling-0.0.1/querymodelling/sql.py

@@ -1,111 +0,0 @@
-from datetime import datetime
-from sqlmodel import Session, select, func
-from sqlalchemy.orm.attributes import InstrumentedAttribute
-from typing import TypeVar, Sequence, Type, Callable, Concatenate, ParamSpec
-
-from .base import get_functions, DefaultSort
-from .fields import QueryField, SortField
-from .model import PageQuery
-
-
-T = TypeVar("T")
-PK = ParamSpec("PK")
-Q = TypeVar("Q", bound=PageQuery)
-
-def sortable_by(field):
-    def wrapper(order: DefaultSort):
-        if order == "desc":
-            return field.desc()
-    return wrapper
-
-def ExtendedTextSearch(BaseField) -> Callable[
-        Concatenate[Callable, PK], T]:
-    def field_wrapper(field, *args, **kwargs):
-        def query(value):
-            if value.startswith("startswith:"):
-                return field.like(f"{value[11:]}%")
-            if value.startswith("endswith:"):
-                return field.like(f"%{value[9:]}")
-            if value.startswith("contains:"):
-                return field.like(f"%{value[9:]}%")
-            return field == value
-        return QueryField(BaseField)(
-            query,
-            *args,
-            pattern="^(?:(?:startswith:|endswith:|contains))?.+",
-            **kwargs
-        )
-    return field_wrapper
-
-def retrieve_entries(
-    query: Q,
-    session: Session,
-    t: Type[T],
-    t_index: InstrumentedAttribute
-) -> tuple[int, Sequence[T]]:
-    search_clause = get_functions(query, "query")
-    order_clause = get_functions(query, "sort")
-    total_elements = session.exec(select(func.count()).where(
-        *search_clause).select_from(t)).first()
-
-    sub_statement = select(t_index)
-    if search_clause:
-        sub_statement = sub_statement.where(*search_clause)
-    if order_clause:
-        sub_statement = sub_statement.order_by(*order_clause)
-    sub_statement = sub_statement.limit(query.size).offset(
-        query.page * query.size)
-    sub_query = sub_statement.subquery()
-    sub_query_id = sub_query.c.__getattr__(t_index.key)
-
-    statement = select(t).join(
-        sub_query, t_index == sub_query_id)
-
-    return total_elements, session.exec(statement).all()
-
-def create_callback(base_field):
-    def auto_create_callback(
-        source_type: type,
-        field_name: str,
-        field,
-        field_info,
-        annotation
-    ):
-        if annotation == str:
-            yield (
-                field_name,
-                ExtendedTextSearch(base_field)(
-                    source_type.__dict__[field_name],
-                    default=None
-                ),
-                annotation
-            )
-        elif annotation in (datetime, int):
-            yield (
-                f"from_{field_name}",
-                QueryField(base_field)(
-                    lambda value: source_type.__dict__[field_name] >= value,
-                    alias=f"{field_name}.from",
-                    default=None
-                ),
-                annotation
-            )
-            yield (
-                f"to_{field_name}",
-                QueryField(base_field)(
-                    lambda value: source_type.__dict__[field_name] <= value,
-                    alias=f"{field_name}.to",
-                    default=None
-                ),
-                annotation
-            )
-        yield (
-            f"sort_{field_name}",
-            SortField(base_field)(
-                sortable_by(source_type.__dict__[field_name]),
-                alias=f"sort_{field_name}",
-                default=None
-            ),
-            DefaultSort
-        )
-    return auto_create_callback