fquery 0.2__tar.gz → 0.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fquery
-Version: 0.2
+Version: 0.3
 Summary: A graph query engine
 Home-page: https://github.com/adsharma/fquery
 Classifier: Programming Language :: Python :: 3

fquery-0.3/fquery/sqlmodel.py

@@ -0,0 +1,280 @@
+import dataclasses
+from dataclasses import _FIELD, dataclass, field, fields, is_dataclass
+from datetime import date, datetime, time
+from typing import (
+    ClassVar,
+    ForwardRef,
+    List,
+    Optional,
+    Union,
+    get_args,
+    get_origin,
+    get_type_hints,
+)
+
+import inflection
+from sqlalchemy import (
+    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
+}
+
+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.3}/fquery.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fquery
-Version: 0.2
+Version: 0.3
 Summary: A graph query engine
 Home-page: https://github.com/adsharma/fquery
 Classifier: Programming Language :: Python :: 3

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

@@ -0,0 +1,10 @@
+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
+
+[graphql]
+strawberry>=0.37.1

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

@@ -11,7 +11,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="fquery",
-    version="0.2",
+    version="0.3",
     description="A graph query engine",
     url="https://github.com/adsharma/fquery",
     long_description=long_description,
@@ -27,7 +27,12 @@ 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"],
     },
 )

{fquery-0.2 → fquery-0.3}/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.2 → fquery-0.3}/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