fquery 0.2__tar.gz → 0.4__tar.gz

{fquery-0.2 → fquery-0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fquery
-Version: 0.2
+Version: 0.4
 Summary: A graph query engine
 Home-page: https://github.com/adsharma/fquery
 Classifier: Programming Language :: Python :: 3
@@ -9,6 +9,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 Provides-Extra: SQL
+Provides-Extra: df
 Provides-Extra: graphql
 License-File: LICENSE
 

{fquery-0.2 → fquery-0.4}/fquery/malloy_builder.py

@@ -1,7 +1,3 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
 import ast
 import operator
 

fquery-0.4/fquery/polars_builder.py

@@ -0,0 +1,53 @@
+import ast
+import operator
+
+import polars as pl
+
+from .visitor import Visitor
+
+# inspired from pandas.core.computation.ops
+_cmp_ops_syms = (">", "<", ">=", "<=", "==", "!=")
+_cmp_ops_funcs = (
+    operator.gt,
+    operator.lt,
+    operator.ge,
+    operator.le,
+    operator.eq,
+    operator.ne,
+)
+_cmp_ops_dict = dict(zip(_cmp_ops_syms, _cmp_ops_funcs))
+
+
+class PolarsBuilderVisitor(Visitor):
+
+    def __init__(self, id1s):
+        self.polars = None
+        self.polars_stack = []
+        self.visited = set()
+
+    async def visit_leaf(self, query):
+        # TODO: make this columnar and real lazy instead of faking laziness
+        self.polars = pl.DataFrame(await query.as_list()).lazy()
+        while self.polars_stack:
+            func, params = self.polars_stack.pop()
+            self.polars = getattr(self.polars, func)(params)
+
+    async def visit_project(self, query):
+        self.polars_stack.append(("select", query.projector))
+        await self.visit(query.child)
+
+    async def visit_take(self, query):
+        self.polars_stack.append(("limit", query._count))
+        await self.visit(query.child)
+
+    async def visit_where(self, query):
+        left, op, right = query._expr.value.split()
+        right = ast.literal_eval(right)
+        table, field = left.split(".") if "." in left else (self.malloy, left)
+        self.polars_stack.append(("filter", (_cmp_ops_dict[op](pl.col(field), right))))
+        await self.visit(query.child)
+
+    async def visit_order_by(self, query):
+        table, field = query._expr.value.split(".")
+        self.polars_stack.append(("sort", field))
+        await self.visit(query.child)

fquery-0.4/fquery/pydantic.py

@@ -0,0 +1,46 @@
+import dataclasses
+from dataclasses import dataclass, fields
+from typing import Type
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+def pydantic(cls):
+    return model(dataclass(kw_only=True)(cls))
+
+
+def validator(self) -> BaseModel:
+    attrs = {name: getattr(self, name) for name in self.__pydantic__.model_fields}
+    return self.__pydantic__(**attrs)
+
+
+def get_field_def(cls, field):
+    # if the dataclass has a default_factory, or a default value, use it in pydantic Field
+    kwargs = {}
+    if not isinstance(field.default, dataclasses._MISSING_TYPE):
+        kwargs["default"] = field.default
+    if not isinstance(field.default_factory, dataclasses._MISSING_TYPE):
+        kwargs["default_factory"] = field.default_factory
+    return Field(**kwargs)
+
+
+def model(cls: Type) -> Type:
+    """
+    Decorator to convert a dataclass to a Pydantic model.
+    """
+    # Generate the SQLModel class
+    pydantic_cls = type(
+        cls.__name__ + "Model",
+        (BaseModel,),
+        {
+            # Add type annotations to the generated fields
+            "__annotations__": {**{field.name: field.type for field in fields(cls)}},
+            # Actual field defs
+            **{field.name: get_field_def(cls, field) for field in fields(cls)},
+        },
+    )
+    cls.__pydantic__ = pydantic_cls
+    cls.model_config = ConfigDict(extra="ignore")
+    cls.validator = validator
+
+    return cls

{fquery-0.2 → fquery-0.4}/fquery/query.py

@@ -12,6 +12,7 @@ from typing import Dict, List, Optional, Tuple, Type, Union
 from .async_utils import wait_for
 from .execute import AbstractSyntaxTreeVisitor
 from .malloy_builder import MalloyBuilderVisitor
+from .polars_builder import PolarsBuilderVisitor
 from .sql_builder import SQLBuilderVisitor
 from .view_model import ViewModel, get_edges, get_return_type
 from .walk import (
@@ -256,6 +257,16 @@ class Query:
         wait_for(visitor.visit(self))
         return visitor.malloy
 
+    def to_polars(self) -> Tree:
+        visitor = PolarsBuilderVisitor([])
+        wait_for(visitor.visit(self))
+        return visitor.polars.collect()
+
+    async def to_async_polars(self) -> Tree:
+        visitor = PolarsBuilderVisitor([])
+        await visitor.visit(self)
+        return await visitor.polars.collect_async()
+
     def batch_resolve_objs(self) -> List[Dict[str, List[ViewModel]]]:
         return [{str(None): [o for o in (self.resolve_obj(i) for i in self.ids) if o]}]
 

fquery-0.4/fquery/sqlmodel.py

@@ -0,0 +1,283 @@
+import dataclasses
+from dataclasses import _FIELD, dataclass, field, fields, is_dataclass
+from datetime import date, datetime, time
+from typing import (
+    ClassVar,
+    Dict,
+    ForwardRef,
+    List,
+    Optional,
+    Union,
+    get_args,
+    get_origin,
+    get_type_hints,
+)
+
+import inflection
+from sqlalchemy import (
+    JSON,
+    Boolean,
+    Date,
+    DateTime,
+    Float,
+    Integer,
+    LargeBinary,
+    Sequence,
+    String,
+    Time,
+)
+from sqlalchemy.orm.base import Mapped
+from sqlmodel import Column, Field, Relationship, SQLModel
+
+SA_TYPEMAP = {
+    int: Integer,
+    int | None: Integer,
+    float: Float,
+    str: String,
+    bool: Boolean,
+    datetime: DateTime,
+    date: Date,
+    time: Time,
+    bytes: LargeBinary,  # or Binary for smaller data
+    Dict: JSON,
+}
+
+GLOBAL_ID_SEQ = Sequence("global_id_seq")  # define sequence explicitly
+SQL_PK = {"metadata": {"SQL": {"primary_key": True}}}
+
+
+def unique():
+    return field(default=None, metadata={"SQL": {"unique": True}})
+
+
+def foreign_key(name):
+    return field(
+        default=None,
+        metadata={
+            "SQL": {"relationship": True, "back_populates": False, "fk_name": name}
+        },
+    )
+
+
+def one_to_many():
+    return field(default=None, metadata={"SQL": {"relationship": True}})
+
+
+def many_to_one(key_column=None, back_populates=None):
+    ret = field(
+        default=None, metadata={"SQL": {"relationship": True, "many_to_one": True}}
+    )
+    # if key_column is None, we default to {key_table_name}.id
+    if key_column is not None:
+        ret.metadata["SQL"]["key_column"] = key_column
+    if back_populates is not None:
+        ret.metadata["SQL"]["back_populates"] = back_populates
+    return ret
+
+
+def sqlmodel(cls):
+    return model()(dataclass(kw_only=True)(cls))
+
+
+def model(table: bool = True, table_name: str = None, global_id: bool = False):
+    """
+    A decorator that generates a SQLModel from a dataclass.
+
+    Args:
+        table_name (str): The name of the database table. Defaults to the name of the dataclass.
+
+    Returns:
+        A decorator that generates a SQLModel from a dataclass.
+    """
+
+    def sqlmodel(self) -> SQLModel:
+        attrs = {name: getattr(self, name) for name in self.__sqlmodel__.__fields__}
+        return self.__sqlmodel__(**attrs)
+
+    def get_field_def(cls, field) -> Union[Field, Relationship]:
+        sql_meta = field.metadata.get("SQL", {})
+        has_foreign_key = bool(sql_meta.get("foreign_key", None))
+        has_relationship = bool(sql_meta.get("relationship", None))
+        has_unique_constraint = sql_meta.get("unique", False)
+        if has_unique_constraint:
+            return Field(unique=True)
+
+        if not sql_meta or not (has_foreign_key or has_relationship):
+            sql_default_factory = field.default_factory
+            if isinstance(sql_default_factory, dataclasses._MISSING_TYPE):
+                sql_default_factory = None
+            return Field(
+                default_factory=sql_default_factory,
+                # TODO: revisit the idea of using string for unknown types
+                sa_column=Column(
+                    SA_TYPEMAP.get(field.type, String),
+                    GLOBAL_ID_SEQ if global_id else cls.id_seq,
+                    primary_key=(
+                        field.name == "id"
+                        or field.metadata.get("SQL", {}).get("primary_key", False)
+                    ),
+                ),
+            )
+        if has_relationship:
+            back_populates = sql_meta.get("back_populates", None)
+            if back_populates is False:
+                return Relationship()
+            if not back_populates:
+                back_populates = inflection.underscore(cls.__name__)
+                if sql_meta.get("many_to_one", False):
+                    back_populates = inflection.pluralize(back_populates)
+            return Relationship(back_populates=back_populates)
+        if has_foreign_key:
+            return Field(default=None, foreign_key=sql_meta["foreign_key"])
+        raise "Unsupported case"
+
+    def get_field_type(field, cls):
+        sql_meta = field.metadata.get("SQL", {})
+        has_foreign_key = bool(sql_meta.get("foreign_key", None))
+        has_relationship = bool(sql_meta.get("relationship", None))
+        has_many_to_one_relationship = bool(sql_meta.get("many_to_one", None))
+        if has_foreign_key:
+            # Translate ClassName to id type.
+            # TODO: what if the id type is different?
+            return Optional[int]
+        if has_relationship:
+            type_class = field.type
+            other_class = type_class.__args__[0]
+            if has_many_to_one_relationship:
+                try:
+                    type_class = get_type_hints(cls)[field.name]
+                except NameError:
+                    # TODO: log exception?
+                    pass
+                else:
+                    return Optional[other_class.__sqlmodel__]
+        return field.type
+
+    def patch_back_populates_types(field, back_populates, cls, sqlmodel_cls):
+        sql_meta = field.metadata.get("SQL", {})
+        has_relationship = bool(sql_meta.get("relationship", None))
+        has_many_to_one_relationship = bool(sql_meta.get("many_to_one", None))
+        if has_relationship:
+            if has_many_to_one_relationship:
+                type_class = field.type
+                try:
+                    type_class = get_type_hints(cls)[field.name]
+                except NameError:
+                    # TODO: log exception?
+                    pass
+                inner = type_class.__args__[0]
+                if isinstance(inner, ForwardRef):
+                    # can't patch right now. Try at a later time via back_populates
+                    return
+                other_class = inner.__sqlmodel__
+                old = other_class.__annotations__[back_populates]
+                # Should be sqlalchemy.orm.base.Mapped[typing.List[ForwardRef('T')]]
+                # replace it with Mapped[List[sqlmodel_cls]]
+                origin = get_origin(old)
+                inner = get_args(old)
+                if origin == Mapped and len(inner) and get_origin(inner[0]) is list:
+                    other_class.__annotations__[back_populates] = Mapped[
+                        List[sqlmodel_cls]
+                    ]
+                    other_class.sqlmodel_rebuild()
+
+        # Replace Optional['T'] with Optional[TSQLModel]
+        old = field.type
+        origin = get_origin(old)
+        inner = get_args(old)
+        needs_rebuild = False
+        if origin == Union and len(inner) and inner[0] == ForwardRef(cls.__name__):
+            sqlmodel_cls.__annotations__[field.name] = Optional[sqlmodel_cls]
+            needs_rebuild = True
+
+        # Replace Optional[T] with Optional[TSQLModel] if T is a dataclass
+        if origin == Union and len(inner) and is_dataclass(inner[0]):
+            sqlmodel_cls.__annotations__[field.name] = Optional[inner[0].__sqlmodel__]
+            needs_rebuild = True
+
+        if needs_rebuild:
+            sqlmodel_cls.sqlmodel_rebuild()
+
+    def default_table_name(clsname: str) -> str:
+        return inflection.underscore(inflection.pluralize(clsname))
+
+    def decorator(cls):
+        # Check if the class is a dataclass
+        if not is_dataclass(cls):
+            raise ValueError("The class must be a dataclass")
+
+        nonlocal table_name
+        table_name = table_name or default_table_name(cls.__name__)
+
+        if not global_id:
+            cls.id_seq = Sequence(f"{table_name}_seq")
+
+        # Insert any foreign keys as necessary
+        for cfield in fields(cls):
+            sql_meta = cfield.metadata.get("SQL", {})
+            has_relationship = bool(sql_meta.get("relationship", None))
+            if has_relationship:
+                many_to_one = sql_meta.get("many_to_one", False)
+                foreign_key_name = cfield.name + "_id"
+                key_table_name = table_name
+                key_column_name = sql_meta.get("fk_name", f"{key_table_name}.id")
+                if many_to_one:
+                    type_class = cfield.type
+                    other_class = type_class.__args__[0]
+                    if isinstance(other_class, ForwardRef):
+                        other_class = other_class.__forward_arg__
+                    other_class = getattr(other_class, "__name__", other_class)
+                    key_table_name = default_table_name(other_class)
+                    key_column_name = sql_meta.get(
+                        "key_column_name", f"{key_table_name}.id"
+                    )
+                back_populates = sql_meta.get("back_populates", None)
+                if back_populates is False or many_to_one:
+
+                    new_field = field(
+                        default=None,
+                        metadata={"SQL": {"foreign_key": key_column_name}},
+                    )
+                    new_field._field_type = _FIELD
+                    new_field.name = foreign_key_name
+                    new_field.type = Optional[int]
+                    cls.__dataclass_fields__[foreign_key_name] = new_field
+                    setattr(cls, new_field.name, new_field.default)
+
+        # Generate the SQLModel class
+        sqlmodel_cls = type(
+            cls.__name__ + "SQLModel",
+            (SQLModel,),
+            {
+                # Table name is a plural and hence the 's' at the end
+                "__tablename__": table_name,
+                # Add type annotations to the generated fields
+                "__annotations__": {
+                    **{field.name: get_field_type(field, cls) for field in fields(cls)},
+                    **{
+                        "Config": ClassVar,
+                    },
+                },
+                # pydantic wants this
+                "__module__": cls.__module__,
+                "Config": {"exclude": {"__sqlmodel__", "sqlmodel"}},
+                **{field.name: get_field_def(cls, field) for field in fields(cls)},
+            },
+            # For SQLModel's SQLModelMetaClass
+            table=table,
+        )
+        cls.__sqlmodel__ = sqlmodel_cls
+        # Update type annotations in any class with a relationship with this class to point
+        # to the SQLModel, not the dataclass
+        for cfield in fields(cls):
+            if not cfield.name in sqlmodel_cls.__sqlmodel_relationships__:
+                continue
+            rel = sqlmodel_cls.__sqlmodel_relationships__.get(cfield.name, None)
+            if rel and hasattr(rel, "back_populates"):
+                patch_back_populates_types(
+                    cfield, rel.back_populates, cls, sqlmodel_cls
+                )
+        cls.sqlmodel = sqlmodel
+        return cls
+
+    return decorator

{fquery-0.2 → fquery-0.4}/fquery.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fquery
-Version: 0.2
+Version: 0.4
 Summary: A graph query engine
 Home-page: https://github.com/adsharma/fquery
 Classifier: Programming Language :: Python :: 3
@@ -9,6 +9,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 Provides-Extra: SQL
+Provides-Extra: df
 Provides-Extra: graphql
 License-File: LICENSE
 

{fquery-0.2 → fquery-0.4}/fquery.egg-info/SOURCES.txt

@@ -10,6 +10,8 @@ fquery/django.py
 fquery/execute.py
 fquery/fgraphql.py
 fquery/malloy_builder.py
+fquery/polars_builder.py
+fquery/pydantic.py
 fquery/query.py
 fquery/resolve.py
 fquery/sql_builder.py
@@ -30,6 +32,8 @@ tests/graphql_mock_user.py
 tests/mock_user.py
 tests/test_malloy.py
 tests/test_operators.py
+tests/test_polars.py
+tests/test_pydantic.py
 tests/test_sql.py
 tests/test_sqlmodel.py
 tests/test_walk.py

fquery-0.4/fquery.egg-info/requires.txt

@@ -0,0 +1,13 @@
+aioitertools
+
+[SQL]
+duckdb_engine>=0.14.0
+inflection>=0.5.1
+pypika>=0.36.5
+sqlmodel@ git+https://github.com/adsharma/sqlmodel.git@sqlmodel_rebuild
+
+[df]
+polars>=0.12.0
+
+[graphql]
+strawberry>=0.37.1

{fquery-0.2 → fquery-0.4}/setup.py

@@ -11,7 +11,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="fquery",
-    version="0.2",
+    version="0.4",
     description="A graph query engine",
     url="https://github.com/adsharma/fquery",
     long_description=long_description,
@@ -27,7 +27,13 @@ setuptools.setup(
     install_requires=["aioitertools"],
     test_requires=["sqlalchemy >= 2.0.36"],
     extras_require={
-        "SQL": ["pypika >= 0.36.5", "sqlmodel >= 0.0.22", "duckdb_engine >= 0.14.0"],
+        "SQL": [
+            "pypika >= 0.36.5",
+            "sqlmodel@git+https://github.com/adsharma/sqlmodel.git@sqlmodel_rebuild",
+            "duckdb_engine >= 0.14.0",
+            "inflection >= 0.5.1",
+        ],
         "graphql": ["strawberry >= 0.37.1"],
+        "df": ["polars >= 0.12.0"],
     },
 )

{fquery-0.2 → fquery-0.4}/tests/benchmark.py

@@ -2,6 +2,8 @@ import timeit
 from dataclasses import dataclass
 from datetime import datetime
 
+import pydantic
+
 from fquery.sqlmodel import model
 
 
@@ -11,8 +13,17 @@ class User:
     id: int
     name: str
     email: str
-    created_at: datetime = None
-    updated_at: datetime = None
+    created_at: datetime | None = None
+    updated_at: datetime | None = None
+
+
+@pydantic.dataclasses.dataclass
+class UserPydantic:
+    id: int
+    name: str
+    email: str
+    created_at: datetime | None = None
+    updated_at: datetime | None = None
 
 
 def create_user():
@@ -23,6 +34,10 @@ def create_user_sqlmodel():
     return User(1, "John Doe", "john@example.com").sqlmodel()
 
 
+def create_user_pydantic():
+    return UserPydantic(1, "John Doe", "john@example.com")
+
+
 # Run the benchmark
 num_iterations = 100000
 time_taken = timeit.timeit(create_user, number=num_iterations)
@@ -40,3 +55,14 @@ print(f"Creating {num_iterations} User SQL Model objects took {time_taken:.6f} s
 print(
     f"Average time per object creation: {(time_taken / num_iterations) * 1e9:.2f} nanoseconds"
 )
+
+# Run the benchmark
+num_iterations = 100000
+time_taken = timeit.timeit(create_user_pydantic, number=num_iterations)
+
+print(
+    f"Creating {num_iterations} User Pydantic Model objects took {time_taken:.6f} seconds"
+)
+print(
+    f"Average time per object creation: {(time_taken / num_iterations) * 1e9:.2f} nanoseconds"
+)

fquery-0.4/tests/test_polars.py

@@ -0,0 +1,36 @@
+import ast
+import random
+import unittest
+
+import polars as pl
+from polars.testing import assert_frame_equal
+
+from .mock_user import UserQuery
+
+
+class PolarsTests(unittest.TestCase):
+    def setUp(self):
+        random.seed(100)
+        self.maxDiff = None
+
+    def test_project(self):
+        df = (
+            UserQuery(range(1, 10))
+            .project([":id", "name", "age"])
+            .where(ast.Expr("user.age >= 16"))
+            .order_by(ast.Expr("user.age"))
+            .take(3)
+            .to_polars()
+        )
+        expected = pl.DataFrame(
+            {
+                ":id": [1, 4, 2],
+                "name": ["id1", "id4", "id2"],
+                "age": [16, 16, 17],
+            }
+        )
+        assert_frame_equal(expected, df)
+
+
+if __name__ == "__main__":
+    unittest.main()

fquery-0.4/tests/test_pydantic.py

@@ -0,0 +1,34 @@
+from dataclasses import is_dataclass
+
+import pytest
+from pydantic import BaseModel, ValidationError
+
+from fquery.pydantic import pydantic
+
+
+@pydantic
+class User:
+    name: str
+    age: int
+    is_active: bool = True
+
+
+def test_pydantic():
+    u1 = User(name="John Doe", age=42)
+    u2 = User(name="John Doe", age=42, is_active=False)
+    assert is_dataclass(u1)
+    assert is_dataclass(u2)
+
+    v1 = u1.validator()
+    v2 = u2.validator()
+    assert isinstance(v1, BaseModel)
+    assert isinstance(v2, BaseModel)
+
+    assert v1.model_dump() == u1.__dict__
+    assert v2.model_dump() == u2.__dict__
+
+
+def test_pydantic_fail():
+    u1 = User(name="John Doe", age=42.3)
+    with pytest.raises(ValidationError):
+        _ = u1.validator()

{fquery-0.2 → fquery-0.4}/tests/test_sqlmodel.py

@@ -1,25 +1,41 @@
-from dataclasses import dataclass, field
+from dataclasses import field
 from datetime import datetime
+from typing import List, Optional
 
 from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker
 from sqlmodel import SQLModel
 
-from fquery.sqlmodel import SQL_PK, model
+from fquery.sqlmodel import (
+    SQL_PK,
+    foreign_key,
+    many_to_one,
+    one_to_many,
+    sqlmodel,
+    unique,
+)
 
 
-@model(global_id=True)
-@dataclass
+@sqlmodel
 class User:
-    name: str
-    email: str
     id: int | None = None
+    name: str
+    email: str = unique()
     created_at: datetime = None
     updated_at: datetime = None
 
+    friend: Optional["User"] = foreign_key("users.id")
+    reviews: List["Review"] = one_to_many()
+
 
-@model(global_id=True)
-@dataclass
+@sqlmodel
+class Review:
+    id: int | None = None
+    score: int
+    user: Optional[User] = many_to_one("users.id")
+
+
+@sqlmodel
 class Relation:
     src: int | None = field(**SQL_PK)
     type: int = field(**SQL_PK)
@@ -41,9 +57,9 @@ user1 = User(
     email="jane@example.com",
     created_at=datetime.now(),
     updated_at=datetime.now(),
+    friend=user.id,
 )
 
-
 # The following is equivalent to: user.sql_model()
 # from sqlmodel import Field
 # from typing import Optional
@@ -70,7 +86,13 @@ def test_sqlmodel():
         session.add(user1.sqlmodel())
         session.commit()
 
-        relation = Relation(user.id, 1, user1.id, datetime.now(), datetime.now())
+        relation = Relation(
+            src=user.id,
+            type=1,
+            dst=user1.id,
+            created_at=datetime.now(),
+            updated_at=datetime.now(),
+        )
         session.add(relation.sqlmodel())
         session.commit()
         # Read all users from the database

fquery-0.2/fquery/sqlmodel.py

@@ -1,96 +0,0 @@
-from dataclasses import fields, is_dataclass
-from datetime import date, datetime, time
-from typing import ClassVar
-
-from sqlalchemy import (
-    Boolean,
-    Date,
-    DateTime,
-    Float,
-    Integer,
-    LargeBinary,
-    Sequence,
-    String,
-    Time,
-)
-from sqlmodel import Column, Field, SQLModel
-
-SA_TYPEMAP = {
-    int: Integer,
-    int | None: Integer,
-    float: Float,
-    str: String,
-    bool: Boolean,
-    datetime: DateTime,
-    date: Date,
-    time: Time,
-    bytes: LargeBinary,  # or Binary for smaller data
-}
-
-GLOBAL_ID_SEQ = Sequence("global_id_seq")  # define sequence explicitly
-SQL_PK = {"metadata": {"SQL": {"primary_key": True}}}
-
-
-def model(table_name: str = None, global_id: bool = False):
-    """
-    A decorator that generates a SQLModel from a dataclass.
-
-    Args:
-        table_name (str): The name of the database table. Defaults to the name of the dataclass.
-
-    Returns:
-        A decorator that generates a SQLModel from a dataclass.
-    """
-
-    def sqlmodel(self) -> SQLModel:
-        return self.__sqlmodel__(**self.__dict__)
-
-    def decorator(cls):
-        # Check if the class is a dataclass
-        if not is_dataclass(cls):
-            raise ValueError("The class must be a dataclass")
-
-        # Generate the SQLModel class
-        sqlmodel_cls = type(
-            cls.__name__ + "SQLModel",
-            (SQLModel,),
-            {
-                # Table name is a plural and hence the 's' at the end
-                "__tablename__": table_name or cls.__name__.lower() + "s",
-                # Add type annotations to the generated fields
-                "__annotations__": {
-                    **{field.name: field.type for field in fields(cls)},
-                    **{
-                        "Config": ClassVar,
-                    },
-                },
-                # pydantic wants this
-                "__module__": cls.__module__,
-                "Config": {"exclude": {"__sqlmodel__", "sqlmodel"}},
-                **{
-                    field.name: Field(
-                        default_factory=getattr(cls, field.name, None),
-                        # TODO: revisit the idea of using string for unknown types
-                        sa_column=Column(
-                            SA_TYPEMAP.get(field.type, String),
-                            GLOBAL_ID_SEQ if global_id else None,
-                            primary_key=(
-                                field.name == "id"
-                                or field.metadata.get("SQL", {}).get(
-                                    "primary_key", False
-                                )
-                            ),
-                        ),
-                    )
-                    for field in fields(cls)
-                },
-            },
-            # For SQLModel's SQLModelMetaClass
-            table=True,
-        )
-
-        cls.__sqlmodel__ = sqlmodel_cls
-        cls.sqlmodel = sqlmodel
-        return cls
-
-    return decorator

fquery-0.2/fquery.egg-info/requires.txt

@@ -1,9 +0,0 @@
-aioitertools
-
-[SQL]
-duckdb_engine>=0.14.0
-pypika>=0.36.5
-sqlmodel>=0.0.22
-
-[graphql]
-strawberry>=0.37.1