fquery 0.3__tar.gz → 0.5__tar.gz

{fquery-0.3 → fquery-0.5}/LICENSE

@@ -1,6 +1,7 @@
 MIT License
 
-Copyright (c) Facebook, Inc. and its affiliates.
+Copyright (c) Facebook, Inc. and its affiliates, 2015-2020
+Copyright (c) Arun Sharma, 2021-2025
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

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

@@ -1,16 +1,46 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: fquery
-Version: 0.3
+Version: 0.5
 Summary: A graph query engine
 Home-page: https://github.com/adsharma/fquery
+License: MIT
 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
+Requires-Dist: aioitertools
+Provides-Extra: fquery
+Requires-Dist: aioitertools; extra == "fquery"
+Provides-Extra: pydantic
+Requires-Dist: pydantic; extra == "pydantic"
+Provides-Extra: sql
+Requires-Dist: pypika>=0.36.5; extra == "sql"
+Provides-Extra: sqlmodel
+Requires-Dist: sqlmodel>=0.0.42; extra == "sqlmodel"
+Requires-Dist: duckdb_engine>=0.14.0; extra == "sqlmodel"
+Requires-Dist: inflection>=0.5.1; extra == "sqlmodel"
+Requires-Dist: sqlalchemy>=2.0.36; extra == "sqlmodel"
+Provides-Extra: graphql
+Requires-Dist: strawberry-graphql>=0.37.1; extra == "graphql"
+Provides-Extra: polars
+Requires-Dist: polars>=0.12.0; extra == "polars"
+Provides-Extra: pyarrow
+Requires-Dist: pyarrow; extra == "pyarrow"
+Provides-Extra: django
+Requires-Dist: django; extra == "django"
+Provides-Extra: malloy
+Provides-Extra: cypher
+Provides-Extra: ladybug
+Requires-Dist: ladybug>=0.17.0; python_version >= "3.10" and extra == "ladybug"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Provides-Extra: df
+Requires-Dist: polars>=0.12.0; extra == "df"
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
 
 # Overview
 
@@ -58,4 +88,3 @@ fquery with Django and get easy access to graphql functionality
 This project is made available under the Apache License, version 2.0.
 
 See [LICENSE.txt](license.txt) for details.
-

{fquery-0.3 → fquery-0.5}/README.md

@@ -44,4 +44,3 @@ fquery with Django and get easy access to graphql functionality
 This project is made available under the Apache License, version 2.0.
 
 See [LICENSE.txt](license.txt) for details.
-

fquery-0.5/fquery/arrow.py

@@ -0,0 +1,121 @@
+import types
+from collections.abc import Mapping
+from dataclasses import dataclass, fields, is_dataclass
+from datetime import date, datetime, time
+from decimal import Decimal
+from typing import (
+    Any,
+    Dict,
+    List,
+    Tuple,
+    Type,
+    Union,
+    get_args,
+    get_origin,
+    get_type_hints,
+)
+
+import pyarrow as pa
+
+UNION_TYPES = (Union,)
+if hasattr(types, "UnionType"):
+    UNION_TYPES = UNION_TYPES + (types.UnionType,)
+
+
+TYPEMAP = {
+    bool: pa.bool_(),
+    int: pa.int64(),
+    float: pa.float64(),
+    str: pa.string(),
+    bytes: pa.binary(),
+    datetime: pa.timestamp("us"),
+    date: pa.date32(),
+    time: pa.time64("us"),
+    Decimal: pa.decimal128(38, 9),
+}
+
+
+def arrow(cls):
+    return model(dataclass(kw_only=True)(cls))
+
+
+def table(cls, rows) -> pa.Table:
+    return pa.Table.from_pylist(
+        [_record(cls, row) for row in rows], schema=cls.__arrow__
+    )
+
+
+def _record(cls: Type, row) -> Dict[str, Any]:
+    field_names = [field.name for field in fields(cls)]
+    if is_dataclass(row):
+        return {name: getattr(row, name) for name in field_names}
+    if isinstance(row, Mapping):
+        return {name: row[name] for name in field_names}
+    raise TypeError(f"Expected {cls.__name__} instance or mapping, got {type(row)!r}")
+
+
+def _is_optional(origin, args) -> bool:
+    return origin in UNION_TYPES and type(None) in args
+
+
+def _arrow_type(annotation) -> Tuple[pa.DataType, bool]:
+    if isinstance(annotation, pa.DataType):
+        return annotation, False
+
+    origin = get_origin(annotation)
+    args = get_args(annotation)
+
+    if _is_optional(origin, args):
+        non_none = [arg for arg in args if arg is not type(None)]
+        if len(non_none) != 1:
+            raise TypeError(f"Unsupported union type {annotation!r}")
+        arrow_type, _ = _arrow_type(non_none[0])
+        return arrow_type, True
+
+    if origin in (list, List):
+        if len(args) != 1:
+            raise TypeError(f"List fields must specify one item type: {annotation!r}")
+        item_type, _ = _arrow_type(args[0])
+        return pa.list_(item_type), False
+
+    if origin in (dict, Dict):
+        if len(args) != 2:
+            raise TypeError(
+                f"Dict fields must specify key and value types: {annotation!r}"
+            )
+        key_type, _ = _arrow_type(args[0])
+        item_type, _ = _arrow_type(args[1])
+        return pa.map_(key_type, item_type), False
+
+    try:
+        return TYPEMAP[annotation], False
+    except KeyError:
+        raise TypeError(f"Unsupported Arrow field type {annotation!r}") from None
+
+
+def _nullable(field, annotation_nullable: bool) -> bool:
+    if annotation_nullable:
+        return True
+    return field.default is None
+
+
+def _schema_field(field, annotation) -> pa.Field:
+    arrow_type, annotation_nullable = _arrow_type(annotation)
+    return pa.field(
+        field.name, arrow_type, nullable=_nullable(field, annotation_nullable)
+    )
+
+
+def model(cls: Type) -> Type:
+    """
+    Decorator to convert a dataclass to a PyArrow-backed row type.
+    """
+    type_hints = get_type_hints(cls)
+    cls.__arrow__ = pa.schema(
+        [
+            _schema_field(field, type_hints.get(field.name, field.type))
+            for field in fields(cls)
+        ]
+    )
+    cls.to_arrow = classmethod(table)
+    return cls

{fquery-0.3 → fquery-0.5}/fquery/async_utils.py

@@ -8,7 +8,11 @@ from contextlib import contextmanager
 
 @contextmanager
 def _get_event_loop():
-    loop = asyncio.get_event_loop()
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
     if not loop.is_running():
         yield loop
     else:

fquery-0.5/fquery/cypher_builder.py

@@ -0,0 +1,194 @@
+# Copyright (c) Arun Sharma, 2025
+#
+# 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 typing import Any
+
+from .naming import query_type_name
+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 CypherBuilderVisitor(Visitor):
+    def __init__(self, id1s):
+        self.cypher = None
+        self.match_parts = []
+        self.current_node = "u"
+        self.where_clauses = []
+        self.return_clause = ""
+        self.order_by_clause = ""
+        self.limit_clause = ""
+        self.visited = set()
+        self.node_counter = 0
+        self.root_label = None
+
+    @staticmethod
+    def table_from_query(query):
+        return query_type_name(query.__class__)
+
+    @staticmethod
+    def _cypher_literal(value: Any) -> str:
+        if value is None:
+            return "null"
+        if isinstance(value, bool):
+            return "true" if value else "false"
+        if isinstance(value, (int, float)):
+            return str(value)
+        if isinstance(value, str):
+            escaped = value.replace("\\", "\\\\").replace("'", "\\'")
+            return f"'{escaped}'"
+        raise TypeError(f"Unsupported Cypher property value {value!r}")
+
+    def _node_pattern(self, var: str, label: str, props=None) -> str:
+        if not props:
+            return f"({var}:{label})"
+        prop_list = ", ".join(
+            f"{name}: {self._cypher_literal(value)}" for name, value in props.items()
+        )
+        return f"({var}:{label} {{{prop_list}}})"
+
+    def _get_next_node_var(self):
+        self.node_counter += 1
+        return f"n{self.node_counter}"
+
+    async def visit_leaf(self, query):
+        if not self.root_label:
+            self.root_label = self.table_from_query(query)
+            self.match_parts = [
+                self._node_pattern(
+                    self.current_node,
+                    self.root_label,
+                    getattr(query, "_match_props", None),
+                )
+            ]
+
+        if query in self.visited:
+            # Prevent infinite recursion
+            return
+        else:
+            self.visited.add(query)
+        for q in query.edges:
+            await self.visit(q)
+
+    async def visit_project(self, query):
+        await self.visit(query.child)
+        proj = ", ".join(
+            [
+                f"{self.current_node}.{x}" if x != ":id" else f"{self.current_node}.id"
+                for x in query.projector
+            ]
+        )
+        self.return_clause = f"RETURN {proj}"
+
+    async def visit_take(self, query):
+        await self.visit(query.child)
+        self.limit_clause = f"LIMIT {query._count}"
+
+    async def visit_where(self, query):
+        await self.visit(query.child)
+        # 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.cypher, left)
+        self.where_clauses.append(f"{self.current_node}.{field} {op} {right}")
+
+    async def visit_order_by(self, query):
+        await self.visit(query.child)
+        key = query._expr.value
+        table, field = key.split(".") if "." in key else (self.cypher, key)
+        self.order_by_clause = f"ORDER BY {self.current_node}.{field}"
+
+    async def visit_edge(self, query):
+        # Ensure we have the root label and initial match part
+        if not self.root_label:
+            # Find the root query
+            root_query = query
+            while hasattr(root_query, "child") and root_query.child:
+                root_query = root_query.child
+            if hasattr(root_query, "__class__"):
+                self.root_label = self.table_from_query(root_query)
+                self.match_parts = [
+                    self._node_pattern(
+                        self.current_node,
+                        self.root_label,
+                        getattr(root_query, "_match_props", None),
+                    )
+                ]
+
+        edge_name = query.edge_name
+
+        # Check if this is part of a multi-hop pattern of the same edge type
+        # Look ahead to see if the child has another edge of the same type
+        has_same_edge_child = (
+            hasattr(query, "child")
+            and hasattr(query.child, "OP")
+            and query.child.OP.name == "EDGE"
+            and query.child.edge_name == edge_name
+        )
+
+        if has_same_edge_child:
+            root_query = query
+            while hasattr(root_query, "child") and root_query.child:
+                root_query = root_query.child
+            # Count the total number of consecutive edges of the same type
+            hops = 1  # current edge
+            current_query = query.child
+            while (
+                hasattr(current_query, "OP")
+                and current_query.OP.name == "EDGE"
+                and current_query.edge_name == edge_name
+            ):
+                hops += 1
+                current_query = current_query.child
+
+            # This is the start of a multi-hop pattern (e.g., friend-of-friend, etc.)
+            self.match_parts = [
+                self._node_pattern(
+                    "a",
+                    self.root_label,
+                    getattr(root_query, "_match_props", None),
+                ),
+                f"[e:{edge_name.upper()}*{hops}..{hops}]",
+                f"(b:{self.root_label})",
+            ]
+            self.current_node = "b"
+            # Skip visiting the intermediate edges and visit the query after the chain
+            await self.visit(current_query)
+        else:
+            # Regular edge traversal
+            child_label = self.table_from_query(query._unbound)
+            next_node = self._get_next_node_var()
+            relationship = f"[:{edge_name.upper()}]"
+            self.match_parts.append(f"{relationship}->({next_node}:{child_label})")
+            self.current_node = next_node
+            await self.visit(query.child)
+
+    async def visit_union(self, query):
+        # UNION in Cypher - this is complex, would need to handle multiple queries
+        # For now, just visit the child
+        await self.visit(query.child)
+
+    async def visit_count(self, query):
+        await self.visit(query.child)
+        self.return_clause = "RETURN count(*)"
+
+    async def visit_nest(self, query):
+        # Nesting - not directly supported in Cypher
+        await self.visit(query.child)
+
+    async def visit_let(self, query):
+        # LET - for renaming, could be handled with AS in RETURN
+        await self.visit(query.child)