fquery 0.1__tar.gz → 0.3__tar.gz

fquery-0.3/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.1
+Name: fquery
+Version: 0.3
+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.3}/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.3}/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.3}/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.3/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.3}/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.3/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.3}/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.3}/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.3}/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)