fquery 0.1__tar.gz → 0.2__tar.gz

fquery-0.2/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.1
+Name: fquery
+Version: 0.2
+Summary: A graph query engine
+Home-page: https://github.com/adsharma/fquery
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Provides-Extra: SQL
+Provides-Extra: graphql
+License-File: LICENSE
+
+# Overview
+
+Projects such as Django and Flask ship with what is known as ORM (object
+relational mappers). These abstractions expose much of the underlying
+relational behavior (both in schema and queries).This project on the
+other hand allows a programmer to stay entirely in the object domain
+(hiding any relational functionality contained within), while still
+allowing transparent mapping to a relational database.
+
+Only basic transparent mapping of fqueries to SQL is supported:
+[Demo](https://github.com/adsharma/fquery/blob/main/tests/test_sql.py).
+
+Only basic transparent mapping of fqueries to [malloy](https://www.malloydata.dev/) is supported:
+[Demo](https://github.com/adsharma/fquery/blob/main/tests/test_malloy.py).
+
+# Installation
+
+Requires python3.x
+
+```
+pip3 install fquery
+```
+
+Running tests:
+
+```
+alias t=pytest-3
+t
+```
+
+You can also run it via tox.
+
+# Tutorial
+
+[Intro](https://adsharma.github.io/fquery/): What is fquery, sample queries
+and some information on internals.
+
+[Blog post](https://adsharma.github.io/django-fquery/) on how to use
+fquery with Django and get easy access to graphql functionality
+
+
+# License
+
+This project is made available under the Apache License, version 2.0.
+
+See [LICENSE.txt](license.txt) for details.
+

{fquery-0.1 → fquery-0.2}/README.md

@@ -5,8 +5,13 @@ relational mappers). These abstractions expose much of the underlying
 relational behavior (both in schema and queries).This project on the
 other hand allows a programmer to stay entirely in the object domain
 (hiding any relational functionality contained within), while still
-allowing transparent mapping to a relational database. This transparent
-mapping functionality is not included in this release.
+allowing transparent mapping to a relational database.
+
+Only basic transparent mapping of fqueries to SQL is supported:
+[Demo](https://github.com/adsharma/fquery/blob/main/tests/test_sql.py).
+
+Only basic transparent mapping of fqueries to [malloy](https://www.malloydata.dev/) is supported:
+[Demo](https://github.com/adsharma/fquery/blob/main/tests/test_malloy.py).
 
 # Installation
 
@@ -25,6 +30,15 @@ t
 
 You can also run it via tox.
 
+# Tutorial
+
+[Intro](https://adsharma.github.io/fquery/): What is fquery, sample queries
+and some information on internals.
+
+[Blog post](https://adsharma.github.io/django-fquery/) on how to use
+fquery with Django and get easy access to graphql functionality
+
+
 # License
 
 This project is made available under the Apache License, version 2.0.

{fquery-0.1 → fquery-0.2}/fquery/aitertools.py

@@ -3,7 +3,6 @@
 # This source code is licensed under the MIT license found in the
 # LICENSE file in the root directory of this source tree.
 import asyncio
-
 from typing import (
     Any,
     AsyncGenerator,
@@ -17,7 +16,6 @@ from typing import (
     Union,
 )
 
-
 T = TypeVar("T")
 AnyIterable = Union[Iterable[T], AsyncIterable[T]]
 

{fquery-0.1 → fquery-0.2}/fquery/async_utils.py

@@ -3,7 +3,6 @@
 # This source code is licensed under the MIT license found in the
 # LICENSE file in the root directory of this source tree.
 import asyncio
-
 from contextlib import contextmanager
 
 

fquery-0.2/fquery/django.py

@@ -0,0 +1,45 @@
+import dataclasses
+from datetime import date, datetime
+from uuid import UUID
+
+from django.db import models
+from django.db.models.fields import (
+    BooleanField,
+    DateField,
+    DateTimeField,
+    FloatField,
+    IntegerField,
+    TextField,
+    UUIDField,
+)
+from django.db.models.fields.related import ForeignKey
+
+from .view_model import get_edges, get_return_type
+
+
+def model(cls):
+    def make_django_model(name, bases, **kwattrs):
+        return type(name, bases, dict(**kwattrs))
+
+    def map_type(dataclass_field):
+        DATACLASS_TO_DJANGO_FIELD = {
+            int: IntegerField,
+            float: FloatField,
+            bool: BooleanField,
+            # TODO: Figure out how to expose CharField
+            str: TextField,
+            datetime: DateTimeField,
+            date: DateField,
+            UUID: UUIDField,
+        }
+        return DATACLASS_TO_DJANGO_FIELD.get(dataclass_field, TextField)()
+
+    fields = dataclasses.fields(cls)
+    django_fields = {djf.name: map_type(djf.type) for djf in fields if djf.name != "id"}
+    django_fields["__module__"] = cls.__module__
+    django_foreign_key_funcs = get_edges(cls)
+    for name, f in django_foreign_key_funcs.items():
+        ret_type = get_return_type(f._old)
+        name = "_" + name  # so it doesn't conflict with the async method name
+        django_fields[name] = ForeignKey(ret_type, on_delete=models.CASCADE)
+    return make_django_model(cls.__name__, (models.Model,), **django_fields)

{fquery-0.1 → fquery-0.2}/fquery/execute.py

@@ -3,15 +3,15 @@
 # This source code is licensed under the MIT license found in the
 # LICENSE file in the root directory of this source tree.
 # Copyright (c) 2016-present, Facebook, Inc. All rights reserved.
-import aioitertools
 import asyncio
 import heapq
 import itertools
 import operator
-
 from functools import partial
 from typing import Any, AsyncGenerator, Callable, Iterable, List
 
+import aioitertools
+
 from .aitertools import tee as aitertools_tee
 from .resolve import VISITED_EDGES_KEY
 from .view_model import ViewModel
@@ -162,8 +162,8 @@ class AbstractSyntaxTreeVisitor(Visitor):
 
     async def finish(self):
         """Setup funcs in reverse order. On entry,
-           p[pkey] may be [orig, a, b, c]
-           On exit, it changes to a coroutine returning c(b(a(orig)))."""
+        p[pkey] may be [orig, a, b, c]
+        On exit, it changes to a coroutine returning c(b(a(orig)))."""
         if not self.parent_iter:
             return
         pkey = str(self.parent_key)
@@ -177,15 +177,15 @@ class AbstractSyntaxTreeVisitor(Visitor):
 
     def nested(func):
         """Apply self.map_func to all the values in the map.
-           map_func takes a list of ViewModels as the argument
+        map_func takes a list of ViewModels as the argument
         """
 
         async def _insert_parent_func(self, func):
-            """ Given a recursive dict in self.iter backed by generator
-                expressions, insert `func' right above the leaves.
+            """Given a recursive dict in self.iter backed by generator
+            expressions, insert `func' right above the leaves.
 
-                self.parent_iter and self.parent_key are used to
-                quickly locate the parents of leaf nodes.
+            self.parent_iter and self.parent_key are used to
+            quickly locate the parents of leaf nodes.
             """
             if not self.parent_iter or not self.parent_key:
                 self.iter = aioitertools.map(

fquery-0.2/fquery/malloy_builder.py

@@ -0,0 +1,86 @@
+# 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
+
+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 MalloyBuilderVisitor(Visitor):
+    INDENT = 2
+
+    def __init__(self, id1s):
+        self.malloy = None
+        self.malloy_stack = []
+        self.visited = set()
+
+    @staticmethod
+    def table_from_query(query):
+        query_name = query.__class__.__name__.lower()
+        # UserQuery -> user
+        query_name = query_name.split("query")[0]
+        return query_name
+
+    @staticmethod
+    def _indent():
+        return " " * MalloyBuilderVisitor.INDENT
+
+    async def visit_leaf(self, query):
+        table = self.table_from_query(query)
+        qstr = f"run: duckdb.table('{table}') -> {{\n"
+        while self.malloy_stack:
+            func = self.malloy_stack.pop()
+            qstr = func(qstr)
+
+        if query in self.visited:
+            # Prevent infinite recursion
+            return
+        else:
+            self.visited.add(query)
+        for q in query.edges:
+            await self.visit(q)
+        qstr += "}"
+        self.malloy = qstr
+
+    async def visit_project(self, query):
+        proj = ", ".join([x if x != ":id" else "id" for x in query.projector])
+        self.malloy_stack.append(lambda x: x + self._indent() + f"select: {proj}\n")
+        await self.visit(query.child)
+
+    async def visit_take(self, query):
+        self.malloy_stack.append(
+            lambda x: x + self._indent() + f"limit: {query._count}\n"
+        )
+        await self.visit(query.child)
+
+    async def visit_where(self, query):
+        # TODO: more general lazy expression evaluator
+        left, op, right = query._expr.value.split()
+        right = ast.literal_eval(right)
+        table, field = left.split(".") if "." in left else (self.malloy, left)
+        self.malloy_stack.append(
+            lambda x: x + self._indent() + f"where: {table}.{field} {op} {right}\n"
+        )
+        await self.visit(query.child)
+
+    async def visit_order_by(self, query):
+        key = query._expr.value
+        table, field = key.split(".") if "." in key else (self.malloy, key)
+        self.malloy_stack.append(
+            lambda x: x + self._indent() + f"order_by: {table}.{field}\n"
+        )
+        await self.visit(query.child)

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

@@ -5,17 +5,17 @@
 import ast
 import itertools
 import traceback
-
 from enum import IntEnum
-from typing import get_type_hints, Dict, ForwardRef, List, Optional, Tuple, Type, Union
 from types import FunctionType
+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 .sql_builder import SQLBuilderVisitor
+from .view_model import ViewModel, get_edges, get_return_type
 from .walk import (
     EdgeContext,
-    ViewModel,
     PrintASTVisitor,
     Tree,
     materialize_walk,
@@ -86,7 +86,8 @@ class Query:
         self._to_json = False
 
     def __str__(self) -> str:
-        query_name = str(self.OP)[len("QueryableOp.") :]
+        # black and flake8 don't agree on formatting the next line
+        query_name = str(self.OP)[len("QueryableOp.") :]  # noqa: E203
         if self.OP == QueryableOp.LEAF:
             return f"{query_name} ({self.__class__.__name__})"
         else:
@@ -250,6 +251,11 @@ class Query:
         wait_for(visitor.visit(self))
         return visitor.sql
 
+    def to_malloy(self) -> str:
+        visitor = MalloyBuilderVisitor([])
+        wait_for(visitor.visit(self))
+        return visitor.malloy
+
     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]}]
 
@@ -277,27 +283,23 @@ class Query:
 
 
 def query(cls):
-    def get_return_type(func):
-        ret = get_type_hints(func)["return"]
-        if hasattr(ret, "_name") and ret._name == "List":
-            ret = ret.__args__[0]
-        if isinstance(ret, ForwardRef):
-            return ret.__forward_arg__
-        if isinstance(ret, type):
-            return ret.__name__
-        return ret
+    def constructor(self, ids=None, items=None):
+        Query.__init__(self, None, ids, items)
+
+    @staticmethod
+    def resolve_obj(_id: int, edge: str = "") -> Optional[ViewModel]:
+        return cls.TYPE.get(_id)
 
     cls = type(cls.__name__, (Query,), dict(cls.__dict__))
     node_cls = cls.TYPE
-    edges = [
-        (name, func)
-        for name, func in node_cls.__dict__.items()
-        if hasattr(func, "_edge")
-    ]
+    edges = get_edges(node_cls)
     cls.EDGE_NAME_TO_RETURN_TYPE = {
-        name: get_return_type(func._old) for name, func in edges
+        name: get_return_type(func._old) for name, func in edges.items()
     }
     Query.ALL_QUERIES.append(cls)
+    cls.OP = QueryableOp.LEAF
+    cls.__init__ = constructor
+    cls.resolve_obj = resolve_obj
     return cls
 
 

{fquery-0.1 → fquery-0.2}/fquery/resolve.py

@@ -3,13 +3,11 @@
 # This source code is licensed under the MIT license found in the
 # LICENSE file in the root directory of this source tree.
 import logging
-
+from asyncio import iscoroutinefunction
 from collections.abc import AsyncGenerator
 
-from asyncio import iscoroutinefunction
 from .async_utils import wait_for
 
-
 VISITED_EDGES_KEY = "__visited_edges__"
 
 logger = logging.getLogger("fquery")

{fquery-0.1 → fquery-0.2}/fquery/sql_builder.py

@@ -6,6 +6,7 @@ import ast
 import operator
 
 from pypika import Query, Tables
+
 from .visitor import Visitor
 
 # inspired from pandas.core.computation.ops
@@ -62,7 +63,7 @@ class SQLBuilderVisitor(Visitor):
         left, op, right = query._expr.value.split()
         right = ast.literal_eval(right)
         table, field = left.split(".") if "." in left else (self.sql, left)
-        if type(table) == str:
+        if type(table) is str:
             table = Tables(table)[0]
         binary_op = _cmp_ops_dict[op]
         self.sql_stack.append(
@@ -73,7 +74,7 @@ class SQLBuilderVisitor(Visitor):
     async def visit_order_by(self, query):
         key = query._expr.value
         table, field = key.split(".") if "." in key else (self.sql, key)
-        if type(table) == str:
+        if type(table) is str:
             table = Tables(table)[0]
         self.sql_stack.append(lambda x: x.orderby(table.__getattr__(field)))
         await self.visit(query.child)

fquery-0.2/fquery/sqlmodel.py

@@ -0,0 +1,96 @@
+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.1 → fquery-0.2}/fquery/view_model.py

@@ -3,8 +3,10 @@
 # This source code is licensed under the MIT license found in the
 # LICENSE file in the root directory of this source tree.
 # Copyright (c) 2016-present, Facebook, Inc. All rights reserved.
+import inspect
 from collections import OrderedDict
 from dataclasses import dataclass
+from typing import ForwardRef, get_type_hints
 
 from .resolve import VISITED_EDGES_KEY
 
@@ -12,7 +14,7 @@ from .resolve import VISITED_EDGES_KEY
 @dataclass
 class ViewModel(OrderedDict):
     """Like an OrderedDict, but treats :id as special for
-       equality purposes and hashable (so you can create sets).
+    equality purposes and hashable (so you can create sets).
     """
 
     id: int
@@ -82,3 +84,22 @@ def edge(fn):
     decorated._edge = True
     decorated._old = fn
     return decorated
+
+
+def get_edges(cls):
+    return {
+        name: f
+        for name, f in inspect.getmembers(cls, predicate=inspect.isfunction)
+        if hasattr(f, "_edge")
+    }
+
+
+def get_return_type(func):
+    ret = get_type_hints(func)["return"]
+    if hasattr(ret, "_name") and ret._name == "List":
+        ret = ret.__args__[0]
+    if isinstance(ret, ForwardRef):
+        return ret.__forward_arg__
+    if isinstance(ret, type):
+        return ret.__name__
+    return ret

{fquery-0.1 → fquery-0.2}/fquery/visitor.py

@@ -12,23 +12,23 @@ class Visitor:
     async def visit(self, node):
         """Visit a node.
 
-           Input is assumed to be validated json against a schema.
-           Dispatch to a visit_foo if the first element in the json
-           is foo.
+        Input is assumed to be validated json against a schema.
+        Dispatch to a visit_foo if the first element in the json
+        is foo.
         """
         if not node:
             return
         if isinstance(node, Callable):
             return self.visit_callable(node)
-        name = str(node.OP).lower().split(".")[-1]
+        name = node.OP.name.lower()
         meth = getattr(self, "visit_" + name, None)
         await meth(node)
 
     async def visit_child(self, child):
         """To be called whenever a node with multiple children
-           needs to visit children. Compared to visit(), this can
-           do cleanup work that needs to be scheduled after each
-           child."""
+        needs to visit children. Compared to visit(), this can
+        do cleanup work that needs to be scheduled after each
+        child."""
         await self.visit(child)
         await self.finish()
 

{fquery-0.1 → fquery-0.2}/fquery/walk.py

@@ -6,15 +6,14 @@
 
 """This module contains various walkers to traverse the lazy map.
 
-   Utilities to walk only the leaves, modify them, insert an interator
-   above, materialzie all the lazy operators, print values and print types.
+   Utilities to walk only the leaves, modify them, insert an iterator
+   above, materialze all the lazy operators, print values and print types.
 """
 import asyncio
-import itertools
 import inspect
+import itertools
 import re
 import types
-
 from collections.abc import Iterable
 from datetime import datetime
 from inspect import isasyncgen, iscoroutine, isfunction, isgenerator
@@ -110,8 +109,8 @@ async def _walk(parent, key, d):  # noqa - ignore function is too complex
 def walk(d):
     """Walk the dictionary, yielding tuples of (root, parent, key, leaf).
 
-       This is particularly useful if you want to iterate over
-       leaves, while also expanding the tree by adding more children
+    This is particularly useful if you want to iterate over
+    leaves, while also expanding the tree by adding more children
     """
     for parent, key, leaf in _walk({}, None, d):
         yield (d, parent, key, leaf)
@@ -119,7 +118,7 @@ def walk(d):
 
 async def leaf_it(d):
     """Similar to walk above, but doesn't provide reference to
-       parent"""
+    parent"""
     async for _parent, _key, leaf in _walk({}, None, d):
         yield leaf
 
@@ -172,16 +171,16 @@ WALK_LIMIT = 5  # max number of items in dict or values in iterator to print
 
 def print_walk(d, indent=0):  # noqa - ignore print walk is too complex
     """Dumps a lazy dictionary without expanding
-       any lazy data structures such as iterators, generators
+    any lazy data structures such as iterators, generators
     """
     # workaround to suppress 'print used in library context' lint
     # instead of suppressing on every line
     log = print
 
     log(INDENT * indent, end="")
-    from query import (
+    from query import (  # noqa - inner import as query depends on walk to walk query
         Query,
-    )  # noqa - inner import as query depends on walk to walk query
+    )
 
     if isinstance(d, primitive) or d is None or isinstance(d, Query):
         log(d)
@@ -243,16 +242,16 @@ def print_walk(d, indent=0):  # noqa - ignore print walk is too complex
 
 async def materialize_walk(d) -> Tree:
     """Returns a materialized dictionary expanding
-       any lazy data structures such as iterators, generators
-       encountered.
+    any lazy data structures such as iterators, generators
+    encountered.
     """
     return await _materialize_walk(d)
 
 
 async def materialize_walk_obj(d) -> Tree:
     """Returns an object graph expanding
-       any lazy data structures such as iterators, generators
-       encountered.
+    any lazy data structures such as iterators, generators
+    encountered.
     """
     return await _materialize_walk_obj(d)
 
@@ -344,7 +343,7 @@ async def _materialize_walk_obj(d) -> Tree:
         return await asyncio.gather(
             *(val for val in (_materialize_walk_obj(v) for v in resolved) if val)
         )
-    elif type(d) == types.AsyncGeneratorType:
+    elif type(d) is types.AsyncGeneratorType:
         d_list = [i async for i in d]  # TODO: Optimize
         resolved = await resolve_parallel_iterable(d_list)
         return await asyncio.gather(
@@ -393,7 +392,7 @@ async def _materialize_walk(d) -> Tree:
         return await asyncio.gather(
             *(val for val in (_materialize_walk(v) for v in resolved) if val)
         )
-    elif type(d) == types.AsyncGeneratorType:
+    elif type(d) is types.AsyncGeneratorType:
         d_list = [i async for i in d]  # TODO: Optimize
         resolved = await resolve_parallel_iterable(d_list)
         return await asyncio.gather(

fquery-0.2/fquery.egg-info/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.1
+Name: fquery
+Version: 0.2
+Summary: A graph query engine
+Home-page: https://github.com/adsharma/fquery
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Provides-Extra: SQL
+Provides-Extra: graphql
+License-File: LICENSE
+
+# Overview
+
+Projects such as Django and Flask ship with what is known as ORM (object
+relational mappers). These abstractions expose much of the underlying
+relational behavior (both in schema and queries).This project on the
+other hand allows a programmer to stay entirely in the object domain
+(hiding any relational functionality contained within), while still
+allowing transparent mapping to a relational database.
+
+Only basic transparent mapping of fqueries to SQL is supported:
+[Demo](https://github.com/adsharma/fquery/blob/main/tests/test_sql.py).
+
+Only basic transparent mapping of fqueries to [malloy](https://www.malloydata.dev/) is supported:
+[Demo](https://github.com/adsharma/fquery/blob/main/tests/test_malloy.py).
+
+# Installation
+
+Requires python3.x
+
+```
+pip3 install fquery
+```
+
+Running tests:
+
+```
+alias t=pytest-3
+t
+```
+
+You can also run it via tox.
+
+# Tutorial
+
+[Intro](https://adsharma.github.io/fquery/): What is fquery, sample queries
+and some information on internals.
+
+[Blog post](https://adsharma.github.io/django-fquery/) on how to use
+fquery with Django and get easy access to graphql functionality
+
+
+# License
+
+This project is made available under the Apache License, version 2.0.
+
+See [LICENSE.txt](license.txt) for details.
+

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

@@ -6,11 +6,14 @@ setup.py
 fquery/__init__.py
 fquery/aitertools.py
 fquery/async_utils.py
+fquery/django.py
 fquery/execute.py
 fquery/fgraphql.py
+fquery/malloy_builder.py
 fquery/query.py
 fquery/resolve.py
 fquery/sql_builder.py
+fquery/sqlmodel.py
 fquery/view_model.py
 fquery/visitor.py
 fquery/walk.py
@@ -21,9 +24,13 @@ fquery.egg-info/requires.txt
 fquery.egg-info/top_level.txt
 tests/__init__.py
 tests/async_test.py
+tests/benchmark.py
+tests/django_example_model.py
 tests/graphql_mock_user.py
 tests/mock_user.py
+tests/test_malloy.py
 tests/test_operators.py
 tests/test_sql.py
+tests/test_sqlmodel.py
 tests/test_walk.py
 tests/test_walk_obj.py

{fquery-0.1 → fquery-0.2}/fquery.egg-info/requires.txt

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

{fquery-0.1 → fquery-0.2}/pyproject.toml

@@ -4,3 +4,5 @@ requires = [
     "wheel"
 ]
 build-backend = "setuptools.build_meta"
+[tool.isort]
+profile = "black"

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

@@ -11,8 +11,9 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="fquery",
-    version="0.1",
+    version="0.2",
     description="A graph query engine",
+    url="https://github.com/adsharma/fquery",
     long_description=long_description,
     long_description_content_type="text/markdown",
     packages=setuptools.find_packages(),
@@ -24,5 +25,9 @@ setuptools.setup(
     python_requires=">=3.6",
     test_suite="tests",
     install_requires=["aioitertools"],
-    extras_require={"SQL": ["pypika >= 0.36.5"], "graphql": ["strawberry >= 0.37.1"]},
+    test_requires=["sqlalchemy >= 2.0.36"],
+    extras_require={
+        "SQL": ["pypika >= 0.36.5", "sqlmodel >= 0.0.22", "duckdb_engine >= 0.14.0"],
+        "graphql": ["strawberry >= 0.37.1"],
+    },
 )

{fquery-0.1 → fquery-0.2}/tests/async_test.py

@@ -3,11 +3,25 @@
 # This source code is licensed under the MIT license found in the
 # LICENSE file in the root directory of this source tree.
 import asyncio
+import functools
+import inspect
+from typing import Callable
+
+
+def coroutine(fn: Callable) -> Callable:
+    if inspect.iscoroutinefunction(fn):
+        return fn
+
+    @functools.wraps(fn)
+    async def _wrapper(*args, **kwargs):
+        return fn(*args, **kwargs)
+
+    return _wrapper
 
 
 def async_test(f):
     def wrapper(*args, **kwargs):
-        coro = asyncio.coroutine(f)
+        coro = coroutine(f)
         future = coro(*args, **kwargs)
         loop = asyncio.get_event_loop()
         loop.run_until_complete(future)

fquery-0.2/tests/benchmark.py

@@ -0,0 +1,42 @@
+import timeit
+from dataclasses import dataclass
+from datetime import datetime
+
+from fquery.sqlmodel import model
+
+
+@model()
+@dataclass
+class User:
+    id: int
+    name: str
+    email: str
+    created_at: datetime = None
+    updated_at: datetime = None
+
+
+def create_user():
+    return User(1, "John Doe", "john@example.com")
+
+
+def create_user_sqlmodel():
+    return User(1, "John Doe", "john@example.com").sqlmodel()
+
+
+# Run the benchmark
+num_iterations = 100000
+time_taken = timeit.timeit(create_user, number=num_iterations)
+
+print(f"Creating {num_iterations} User objects took {time_taken:.6f} seconds")
+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_sqlmodel, number=num_iterations)
+
+print(f"Creating {num_iterations} User SQL Model objects took {time_taken:.6f} seconds")
+print(
+    f"Average time per object creation: {(time_taken / num_iterations) * 1e9:.2f} nanoseconds"
+)

fquery-0.2/tests/django_example_model.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass
+
+from fquery.django import model
+from fquery.view_model import node
+
+
+@model
+@dataclass
+@node
+class Person:
+    first_name: str
+    last_name: str
+    age: int

{fquery-0.1 → fquery-0.2}/tests/graphql_mock_user.py

@@ -3,10 +3,12 @@
 # This source code is licensed under the MIT license found in the
 # LICENSE file in the root directory of this source tree.
 # Copyright (c) 2016-present, Facebook, Inc. All rights reserved.
-from fquery.fgraphql import obj, field, graphql, root
-from .mock_user import MockUser, MockReview, UserQuery, ReviewQuery
 from typing import List, Optional
 
+from fquery.fgraphql import field, graphql, obj, root
+
+from .mock_user import MockReview, MockUser, ReviewQuery, UserQuery
+
 
 @obj
 class GraphQLMockUser(MockUser):

{fquery-0.1 → fquery-0.2}/tests/mock_user.py

@@ -5,12 +5,11 @@
 from __future__ import annotations
 
 import random
-
 from dataclasses import dataclass
-from typing import List, Optional
+from typing import List
 
-from fquery.query import query, Query, QueryableOp
-from fquery.view_model import edge, node, ViewModel
+from fquery.query import query
+from fquery.view_model import edge, node
 
 
 @dataclass
@@ -42,19 +41,6 @@ class MockUser:
         return u
 
 
-@query
-class UserQuery:
-    OP = QueryableOp.LEAF
-    TYPE = MockUser
-
-    def __init__(self, ids=None, items=None):
-        Query.__init__(self, None, ids, items)
-
-    @staticmethod
-    def resolve_obj(_id: int, edge: str = "") -> Optional[ViewModel]:
-        return MockUser.get(_id)
-
-
 @dataclass
 @node
 class MockReview:
@@ -79,13 +65,10 @@ class MockReview:
 
 
 @query
-class ReviewQuery:
-    OP = QueryableOp.LEAF
-    TYPE = MockReview
+class UserQuery:
+    TYPE = MockUser
 
-    def __init__(self, ids=None, items=None):
-        Query.__init__(self, None, ids, items)
 
-    @staticmethod
-    def resolve_obj(_id: int, edge: str = "") -> Optional[ViewModel]:
-        return MockReview.get(_id)
+@query
+class ReviewQuery:
+    TYPE = MockReview

fquery-0.2/tests/test_malloy.py

@@ -0,0 +1,40 @@
+# 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 random
+import textwrap
+import unittest
+
+from .mock_user import UserQuery
+
+
+class MalloyTests(unittest.TestCase):
+    def setUp(self):
+        random.seed(100)
+        self.maxDiff = None
+
+    def test_project(self):
+        malloy_q = (
+            UserQuery(range(1, 10))
+            .project([":id", "name"])
+            .where(ast.Expr("user.age >= 16"))
+            .order_by(ast.Expr("user.age"))
+            .take(3)
+            .to_malloy()
+        )
+        expected = textwrap.dedent(
+            """\
+            run: duckdb.table('user') -> {
+              select: id, name
+              where: user.age >= 16
+              order_by: user.age
+              limit: 3
+            }"""
+        )
+        self.assertEqual(expected, malloy_q)
+
+
+if __name__ == "__main__":
+    unittest.main()

{fquery-0.1 → fquery-0.2}/tests/test_operators.py

@@ -7,9 +7,8 @@ import os
 import random
 import unittest
 
-from .mock_user import UserQuery
 from .async_test import async_test
-
+from .mock_user import UserQuery
 
 TEST_DATA = os.path.join(os.path.dirname(__file__), "test_data")
 

{fquery-0.1 → fquery-0.2}/tests/test_sql.py

@@ -6,9 +6,10 @@ import ast
 import random
 import unittest
 
-from .mock_user import UserQuery
 from pypika import Query, Tables
 
+from .mock_user import UserQuery
+
 
 class SQLTests(unittest.TestCase):
     def setUp(self):

fquery-0.2/tests/test_sqlmodel.py

@@ -0,0 +1,80 @@
+from dataclasses import dataclass, field
+from datetime import datetime
+
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from sqlmodel import SQLModel
+
+from fquery.sqlmodel import SQL_PK, model
+
+
+@model(global_id=True)
+@dataclass
+class User:
+    name: str
+    email: str
+    id: int | None = None
+    created_at: datetime = None
+    updated_at: datetime = None
+
+
+@model(global_id=True)
+@dataclass
+class Relation:
+    src: int | None = field(**SQL_PK)
+    type: int = field(**SQL_PK)
+    dst: int = field(**SQL_PK)
+    created_at: datetime = None
+    updated_at: datetime = None
+
+
+# Create a new user. This should be cheap
+user = User(
+    name="John Doe",
+    email="john@example.com",
+    created_at=datetime.now(),
+    updated_at=datetime.now(),
+)
+
+user1 = User(
+    name="Jane Doe",
+    email="jane@example.com",
+    created_at=datetime.now(),
+    updated_at=datetime.now(),
+)
+
+
+# The following is equivalent to: user.sql_model()
+# from sqlmodel import Field
+# from typing import Optional
+# class UserSQLModel(SQLModel, table=True):
+#     __tablename__ = "users"
+#
+#     id: int = Field(primary_key=True)
+#     name: str
+#     email: str
+#     created_at: Optional[datetime] = Field(default_factory=datetime.now)
+#     updated_at: Optional[datetime] = Field(default=None)
+
+
+def test_sqlmodel():
+    user_sql = user.sqlmodel()
+    assert user_sql.__tablename__ == "users"
+    engine = create_engine("duckdb:///:memory:", echo=True)
+    SQLModel.metadata.create_all(engine)
+
+    Session = sessionmaker(bind=engine)
+
+    with Session() as session:
+        session.add(user.sqlmodel())
+        session.add(user1.sqlmodel())
+        session.commit()
+
+        relation = Relation(user.id, 1, user1.id, datetime.now(), datetime.now())
+        session.add(relation.sqlmodel())
+        session.commit()
+        # Read all users from the database
+        users = session.query(User.__sqlmodel__).all()
+        assert len(users) == 2
+        relations = session.query(Relation.__sqlmodel__).all()
+        assert len(relations) == 1

{fquery-0.1 → fquery-0.2}/tests/test_walk.py

@@ -4,9 +4,10 @@
 # LICENSE file in the root directory of this source tree.
 import unittest
 
-from .async_test import async_test
 from fquery.walk import _materialize_walk_sync, materialize_walk
 
+from .async_test import async_test
+
 
 class MaterializeWalkTests(unittest.TestCase):
     def setUp(self):

fquery-0.1/PKG-INFO

@@ -1,48 +0,0 @@
-Metadata-Version: 2.1
-Name: fquery
-Version: 0.1
-Summary: A graph query engine
-Home-page: UNKNOWN
-License: UNKNOWN
-Description: # Overview
-        
-        Projects such as Django and Flask ship with what is known as ORM (object
-        relational mappers). These abstractions expose much of the underlying
-        relational behavior (both in schema and queries).This project on the
-        other hand allows a programmer to stay entirely in the object domain
-        (hiding any relational functionality contained within), while still
-        allowing transparent mapping to a relational database. This transparent
-        mapping functionality is not included in this release.
-        
-        # Installation
-        
-        Requires python3.x
-        
-        ```
-        pip3 install fquery
-        ```
-        
-        Running tests:
-        
-        ```
-        alias t=pytest-3
-        t
-        ```
-        
-        You can also run it via tox.
-        
-        # License
-        
-        This project is made available under the Apache License, version 2.0.
-        
-        See [LICENSE.txt](license.txt) for details.
-        
-        
-Platform: UNKNOWN
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-Provides-Extra: SQL
-Provides-Extra: graphql

fquery-0.1/fquery.egg-info/PKG-INFO

@@ -1,48 +0,0 @@
-Metadata-Version: 2.1
-Name: fquery
-Version: 0.1
-Summary: A graph query engine
-Home-page: UNKNOWN
-License: UNKNOWN
-Description: # Overview
-        
-        Projects such as Django and Flask ship with what is known as ORM (object
-        relational mappers). These abstractions expose much of the underlying
-        relational behavior (both in schema and queries).This project on the
-        other hand allows a programmer to stay entirely in the object domain
-        (hiding any relational functionality contained within), while still
-        allowing transparent mapping to a relational database. This transparent
-        mapping functionality is not included in this release.
-        
-        # Installation
-        
-        Requires python3.x
-        
-        ```
-        pip3 install fquery
-        ```
-        
-        Running tests:
-        
-        ```
-        alias t=pytest-3
-        t
-        ```
-        
-        You can also run it via tox.
-        
-        # License
-        
-        This project is made available under the Apache License, version 2.0.
-        
-        See [LICENSE.txt](license.txt) for details.
-        
-        
-Platform: UNKNOWN
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-Provides-Extra: SQL
-Provides-Extra: graphql

{fquery-0.1 → fquery-0.2}/fquery/fgraphql.py

@@ -3,11 +3,11 @@
 # This source code is licensed under the MIT license found in the
 # LICENSE file in the root directory of this source tree.
 # Copyright (c) 2016-present, Facebook, Inc. All rights reserved.
-import strawberry
 import sys
-
 from enum import Enum
 
+import strawberry
+
 
 def graphql(cls):
     if Enum in cls.__mro__: