fquery 0.3__tar.gz → 0.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fquery
-Version: 0.3
+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.3 → 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.3 → 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.3 → fquery-0.4}/fquery/sqlmodel.py

@@ -3,6 +3,7 @@ from dataclasses import _FIELD, dataclass, field, fields, is_dataclass
 from datetime import date, datetime, time
 from typing import (
     ClassVar,
+    Dict,
     ForwardRef,
     List,
     Optional,
@@ -14,6 +15,7 @@ from typing import (
 
 import inflection
 from sqlalchemy import (
+    JSON,
     Boolean,
     Date,
     DateTime,
@@ -37,6 +39,7 @@ SA_TYPEMAP = {
     date: Date,
     time: Time,
     bytes: LargeBinary,  # or Binary for smaller data
+    Dict: JSON,
 }
 
 GLOBAL_ID_SEQ = Sequence("global_id_seq")  # define sequence explicitly

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fquery
-Version: 0.3
+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.3 → 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.3 → fquery-0.4}/fquery.egg-info/requires.txt

@@ -6,5 +6,8 @@ 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.3 → fquery-0.4}/setup.py

@@ -11,7 +11,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="fquery",
-    version="0.3",
+    version="0.4",
     description="A graph query engine",
     url="https://github.com/adsharma/fquery",
     long_description=long_description,
@@ -34,5 +34,6 @@ setuptools.setup(
             "inflection >= 0.5.1",
         ],
         "graphql": ["strawberry >= 0.37.1"],
+        "df": ["polars >= 0.12.0"],
     },
 )

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()