pytrilogy 0.0.3.61__tar.gz → 0.0.3.64__tar.gz

{pytrilogy-0.0.3.61/pytrilogy.egg-info → pytrilogy-0.0.3.64}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytrilogy
-Version: 0.0.3.61
+Version: 0.0.3.64
 Summary: Declarative, typed query language that compiles to SQL.
 Home-page: 
 Author: 

{pytrilogy-0.0.3.61 → pytrilogy-0.0.3.64/pytrilogy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytrilogy
-Version: 0.0.3.61
+Version: 0.0.3.64
 Summary: Declarative, typed query language that compiles to SQL.
 Home-page: 
 Author: 

{pytrilogy-0.0.3.61 → pytrilogy-0.0.3.64}/tests/test_select.py

@@ -122,6 +122,7 @@ def test_double_aggregate():
 
 
 def test_modifiers():
+
     q1 = """
     const a <- 1;
     const b <- 2;

{pytrilogy-0.0.3.61 → pytrilogy-0.0.3.64}/trilogy/__init__.py

@@ -4,6 +4,6 @@ from trilogy.dialect.enums import Dialects
 from trilogy.executor import Executor
 from trilogy.parser import parse
 
-__version__ = "0.0.3.61"
+__version__ = "0.0.3.64"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

{pytrilogy-0.0.3.61 → pytrilogy-0.0.3.64}/trilogy/core/models/build.py

@@ -1586,7 +1586,10 @@ class Factory:
 
                 return BuildFunction.model_construct(
                     operator=base.operator,
-                    arguments=[rval, *[self.build(c) for c in raw_args[1:]]],
+                    arguments=[
+                        rval,
+                        *[self.handle_constant(self.build(c)) for c in raw_args[1:]],
+                    ],
                     output_datatype=base.output_datatype,
                     output_purpose=base.output_purpose,
                     valid_inputs=base.valid_inputs,
@@ -2042,4 +2045,6 @@ class Factory:
             and base.lineage.operator == FunctionType.CONSTANT
         ):
             return BuildParamaterizedConceptReference(concept=base)
+        elif isinstance(base, ConceptRef):
+            return self.handle_constant(self.build(base))
         return base

{pytrilogy-0.0.3.61 → pytrilogy-0.0.3.64}/trilogy/core/processing/concept_strategies_v3.py

@@ -54,11 +54,7 @@ def generate_candidates_restrictive(
     exhausted: set[str],
     depth: int,
     conditions: BuildWhereClause | None = None,
-) -> List[BuildConcept]:
-    # if it's single row, joins are irrelevant. Fetch without keys.
-    if priority_concept.granularity == Granularity.SINGLE_ROW:
-        return []
-
+) -> tuple[list[BuildConcept], BuildWhereClause | None]:
     local_candidates = [
         x
         for x in list(candidates)
@@ -71,8 +67,16 @@ def generate_candidates_restrictive(
         logger.info(
             f"{depth_to_prefix(depth)}{LOGGER_PREFIX} Injecting additional conditional row arguments as all remaining concepts are roots or constant"
         )
-        return unique(list(conditions.row_arguments) + local_candidates, "address")
-    return local_candidates
+        # otherwise, we can ignore the conditions now that we've injected inputs
+        return (
+            unique(list(conditions.row_arguments) + local_candidates, "address"),
+            None,
+        )
+    # if it's single row, joins are irrelevant. Fetch without keys.
+    if priority_concept.granularity == Granularity.SINGLE_ROW:
+        return [], conditions
+
+    return local_candidates, conditions
 
 
 def append_existence_check(
@@ -104,9 +108,7 @@ def append_existence_check(
             )
             assert parent, "Could not resolve existence clause"
             node.add_parents([parent])
-            logger.info(
-                f"{LOGGER_PREFIX} fetching existence clause inputs {[str(c) for c in subselect]}"
-            )
+            logger.info(f"{LOGGER_PREFIX} found {[str(c) for c in subselect]}")
             node.add_existence_concepts([*subselect])
 
 
@@ -440,7 +442,19 @@ def _search_concepts(
     accept_partial: bool = False,
     conditions: BuildWhereClause | None = None,
 ) -> StrategyNode | None:
+    # check for direct materialization first
+    candidate = history.gen_select_node(
+        mandatory_list,
+        environment,
+        g,
+        depth + 1,
+        fail_if_not_found=False,
+        accept_partial=accept_partial,
+        conditions=conditions,
+    )
 
+    if candidate:
+        return candidate
     context = initialize_loop_context(
         mandatory_list=mandatory_list,
         environment=environment,
@@ -460,19 +474,21 @@ def _search_concepts(
         )
 
         local_conditions = evaluate_loop_conditions(context, priority_concept)
-        logger.info(
-            f"{depth_to_prefix(depth)}{LOGGER_PREFIX} priority concept is {str(priority_concept)} derivation {priority_concept.derivation} granularity {priority_concept.granularity} with conditions {local_conditions}"
-        )
 
         candidates = [
             c for c in context.mandatory_list if c.address != priority_concept.address
         ]
-        candidate_list = generate_candidates_restrictive(
+        # the local conditions list may be override if we end up injecting conditions
+        candidate_list, local_conditions = generate_candidates_restrictive(
             priority_concept,
             candidates,
             context.skip,
             depth=depth,
-            conditions=context.conditions,
+            conditions=local_conditions,
+        )
+
+        logger.info(
+            f"{depth_to_prefix(depth)}{LOGGER_PREFIX} priority concept is {str(priority_concept)} derivation {priority_concept.derivation} granularity {priority_concept.granularity} with conditions {local_conditions}"
         )
 
         logger.info(

{pytrilogy-0.0.3.61 → pytrilogy-0.0.3.64}/trilogy/core/processing/discovery_node_factory.py

@@ -438,15 +438,14 @@ def generate_node(
     )
 
     # Try materialized concept first
+    # this is worth checking every loop iteration
     candidate = history.gen_select_node(
-        concept,
-        local_optional,
+        [concept] + local_optional,
         environment,
         g,
         depth + 1,
         fail_if_not_found=False,
         accept_partial=accept_partial,
-        accept_partial_optional=False,
         conditions=conditions,
     )
 

{pytrilogy-0.0.3.61 → pytrilogy-0.0.3.64}/trilogy/core/processing/node_generators/basic_node.py

@@ -52,6 +52,9 @@ def gen_basic_node(
     synonyms: list[BuildConcept] = []
     ignored_optional: set[str] = set()
     assert isinstance(concept.lineage, BuildFunction)
+    # when we are getting an attribute, if there is anything else
+    # that is an attribute of the same struct in local optional
+    # select that value for discovery as well
     if concept.lineage.operator == FunctionType.ATTR_ACCESS:
         logger.info(
             f"{depth_prefix}{LOGGER_PREFIX} checking for synonyms for attribute access"
@@ -62,7 +65,10 @@ def gen_basic_node(
                 # gate to ensure we don't match to multiple synonyms
                 if found:
                     continue
-                s_concept = environment.alias_origin_lookup[z]
+                if z in environment.concepts:
+                    s_concept = environment.concepts[z]
+                else:
+                    s_concept = environment.alias_origin_lookup[z]
                 if is_equivalent_basic_function_lineage(concept, s_concept):
                     found = True
                     synonyms.append(s_concept)

{pytrilogy-0.0.3.61 → pytrilogy-0.0.3.64}/trilogy/core/processing/node_generators/node_merge_node.py

@@ -239,7 +239,6 @@ def resolve_weak_components(
             if "__preql_internal" not in c.address
         ]
     )
-    logger.debug(f"Resolving weak components for {node_list} in {search_graph.nodes}")
     synonyms: set[str] = set()
     for x in all_concepts:
         synonyms = synonyms.union(x.pseudonyms)

{pytrilogy-0.0.3.61 → pytrilogy-0.0.3.64}/trilogy/core/processing/node_generators/select_merge_node.py

@@ -68,6 +68,8 @@ def get_graph_exact_match(
         if node in datasources:
             ds = datasources[node]
             if not isinstance(ds, list):
+                if not ds.non_partial_for:
+                    continue
                 if ds.non_partial_for and conditions == ds.non_partial_for:
                     exact.add(node)
                     continue
@@ -95,6 +97,31 @@ def get_graph_grains(g: nx.DiGraph) -> dict[str, list[str]]:
     return grain_length
 
 
+def subgraph_is_complete(
+    nodes: list[str], targets: set[str], mapping: dict[str, str]
+) -> bool:
+    mapped = set([mapping.get(n, n) for n in nodes])
+    return all([t in mapped for t in targets])
+
+
+def prune_sources_for_conditions(
+    g: nx.DiGraph,
+    depth: int,
+    conditions: BuildWhereClause | None,
+):
+
+    complete = get_graph_exact_match(g, conditions)
+    to_remove = []
+    for node in g.nodes:
+        if node.startswith("ds~") and node not in complete:
+            to_remove.append(node)
+            logger.debug(
+                f"{padding(depth)}{LOGGER_PREFIX} removing datasource {node} as it is not a match for conditions {conditions}"
+            )
+    for node in to_remove:
+        g.remove_node(node)
+
+
 def create_pruned_concept_graph(
     g: nx.DiGraph,
     all_concepts: List[BuildConcept],
@@ -104,7 +131,10 @@ def create_pruned_concept_graph(
     depth: int = 0,
 ) -> nx.DiGraph:
     orig_g = g
+
     g = g.copy()
+    if conditions:
+        prune_sources_for_conditions(g, depth, conditions)
     union_options = get_union_sources(datasources, all_concepts)
     for ds_list in union_options:
         node_address = "ds~" + "-".join([x.name for x in ds_list])
@@ -183,6 +213,13 @@ def create_pruned_concept_graph(
     )
 
     subgraphs = list(nx.connected_components(g.to_undirected()))
+
+    subgraphs = [
+        s
+        for s in subgraphs
+        if subgraph_is_complete(s, target_addresses, relevant_concepts_pre)
+    ]
+
     if not subgraphs:
         logger.info(
             f"{padding(depth)}{LOGGER_PREFIX} cannot resolve root graph - no subgraphs after node prune"
@@ -486,6 +523,20 @@ def gen_select_merge_node(
     non_constant = [c for c in all_concepts if c.derivation != Derivation.CONSTANT]
     constants = [c for c in all_concepts if c.derivation == Derivation.CONSTANT]
     if not non_constant and constants:
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} only constant inputs to discovery, returning constant node directly"
+        )
+        if conditions:
+            if not all(
+                [x.derivation == Derivation.CONSTANT for x in conditions.row_arguments]
+            ):
+                logger.info(
+                    f"{padding(depth)}{LOGGER_PREFIX} conditions being passed in to constant node {conditions}, but not all concepts are constants."
+                )
+                return None
+            else:
+                constants += conditions.row_arguments
+
         return ConstantNode(
             output_concepts=constants,
             input_concepts=[],
@@ -494,7 +545,7 @@ def gen_select_merge_node(
             depth=depth,
             partial_concepts=[],
             force_group=False,
-            preexisting_conditions=conditions.conditional if conditions else None,
+            conditions=conditions.conditional if conditions else None,
         )
     for attempt in [False, True]:
         pruned_concept_graph = create_pruned_concept_graph(

{pytrilogy-0.0.3.61 → pytrilogy-0.0.3.64}/trilogy/core/processing/node_generators/synonym_node.py

@@ -43,18 +43,49 @@ def gen_synonym_node(
             elif y in environment.concepts:
                 synonyms[x.address].append(environment.concepts[y])
                 synonym_count += 1
+    for address in synonyms:
+        synonyms[address].sort(key=lambda obj: obj.address)
     if synonym_count == 0:
         return None
 
     logger.info(f"{local_prefix} Generating Synonym Node with {len(synonyms)} synonyms")
+    sorted_keys = sorted(synonyms.keys())
+    combinations_list: list[tuple[BuildConcept, ...]] = list(
+        itertools.product(*(synonyms[obj] for obj in sorted_keys))
+    )
+
+    def similarity_sort_key(combo):
+        addresses = [x.address for x in combo]
+
+        # Calculate similarity score - count how many pairs share prefixes
+        similarity_score = 0
+        for i in range(len(addresses)):
+            for j in range(i + 1, len(addresses)):
+                # Find common prefix length
+                addr1_parts = addresses[i].split(".")
+                addr2_parts = addresses[j].split(".")
+                common_prefix_len = 0
+                for k in range(min(len(addr1_parts), len(addr2_parts))):
+                    if addr1_parts[k] == addr2_parts[k]:
+                        common_prefix_len += 1
+                    else:
+                        break
+                similarity_score += common_prefix_len
 
-    combinations = itertools.product(*(synonyms[obj] for obj in synonyms.keys()))
-    for combo in combinations:
+        # Sort by similarity (descending), then by addresses (ascending) for ties
+        return (-similarity_score, addresses)
+
+    combinations_list.sort(key=similarity_sort_key)
+    logger.info(combinations_list)
+    for combo in combinations_list:
         fingerprint = tuple([x.address for x in combo])
         if fingerprint == base_fingerprint:
             continue
+        logger.info(
+            f"{local_prefix} checking combination {fingerprint} with {len(combo)} concepts"
+        )
         attempt: StrategyNode | None = source_concepts(
-            combo,
+            list(combo),
             history=history,
             environment=environment,
             depth=depth,

{pytrilogy-0.0.3.61 → pytrilogy-0.0.3.64}/trilogy/core/processing/nodes/__init__.py

@@ -124,51 +124,31 @@ class History(BaseModel):
             in self.started
         )
 
-    def _select_concepts_to_lookup(
-        self,
-        main: BuildConcept,
-        search: list[BuildConcept],
-        accept_partial: bool,
-        fail_if_not_found: bool,
-        accept_partial_optional: bool,
-        conditions: BuildWhereClause | None = None,
-    ) -> str:
-        return (
-            str(main.address)
-            + "|"
-            + "-".join([c.address for c in search])
-            + str(accept_partial)
-            + str(fail_if_not_found)
-            + str(accept_partial_optional)
-            + str(conditions)
-        )
-
     def gen_select_node(
         self,
-        concept: BuildConcept,
-        local_optional: list[BuildConcept],
+        concepts: list[BuildConcept],
         environment: BuildEnvironment,
         g,
         depth: int,
         fail_if_not_found: bool = False,
         accept_partial: bool = False,
-        accept_partial_optional: bool = False,
         conditions: BuildWhereClause | None = None,
     ) -> StrategyNode | None:
         from trilogy.core.processing.node_generators.select_node import gen_select_node
 
-        fingerprint = self._select_concepts_to_lookup(
-            concept,
-            local_optional,
+        fingerprint = self._concepts_to_lookup(
+            concepts,
             accept_partial,
-            fail_if_not_found,
-            accept_partial_optional=accept_partial_optional,
             conditions=conditions,
         )
         if fingerprint in self.select_history:
-            return self.select_history[fingerprint]
+            rval = self.select_history[fingerprint]
+            if rval:
+                # all nodes must be copied before returning
+                return rval.copy()
+            return rval
         gen = gen_select_node(
-            [concept] + local_optional,
+            concepts,
             environment,
             g,
             depth + 1,
@@ -177,6 +157,8 @@ class History(BaseModel):
             conditions=conditions,
         )
         self.select_history[fingerprint] = gen
+        if gen:
+            return gen.copy()
         return gen
 
 

{pytrilogy-0.0.3.61 → pytrilogy-0.0.3.64}/trilogy/core/statements/author.py

@@ -448,7 +448,7 @@ class TypeDeclaration(BaseModel):
     type: CustomType
 
 
-class FunctionDeclaration(BaseModel):
+class FunctionDeclaration(HasUUID, BaseModel):
     name: str
     args: list[ArgBinding]
     expr: Expr

{pytrilogy-0.0.3.61 → pytrilogy-0.0.3.64}/trilogy/dialect/base.py

@@ -58,6 +58,7 @@ from trilogy.core.query_processor import process_copy, process_persist, process_
 from trilogy.core.statements.author import (
     ConceptDeclarationStatement,
     CopyStatement,
+    FunctionDeclaration,
     ImportStatement,
     MergeStatementV2,
     MultiSelectStatement,
@@ -980,6 +981,7 @@ class BaseDialect:
                     ImportStatement,
                     RowsetDerivationStatement,
                     Datasource,
+                    FunctionDeclaration,
                 ),
             ):
                 continue

pytrilogy-0.0.3.64/trilogy/hooks/graph_hook.py

@@ -0,0 +1,140 @@
+import sys
+from os import environ
+
+import networkx as nx
+
+from trilogy.hooks.base_hook import BaseHook
+
+if not environ.get("TCL_LIBRARY"):
+    minor = sys.version_info.minor
+    if minor == 13:
+        environ["TCL_LIBRARY"] = r"C:\Program Files\Python313\tcl\tcl8.6"
+    elif minor == 12:
+        environ["TCL_LIBRARY"] = r"C:\Program Files\Python312\tcl\tcl8.6"
+    else:
+        pass
+
+
+class GraphHook(BaseHook):
+    def __init__(self):
+        super().__init__()
+        try:
+            pass
+        except ImportError:
+            raise ImportError("GraphHook requires matplotlib and scipy to be installed")
+        # https://github.com/python/cpython/issues/125235#issuecomment-2412948604
+
+    def query_graph_built(
+        self,
+        graph: nx.DiGraph,
+        target: str | None = None,
+        highlight_nodes: list[str] | None = None,
+        remove_isolates: bool = True,
+    ):
+        from matplotlib import pyplot as plt
+
+        graph = graph.copy()
+        nodes = [*graph.nodes]
+        for node in nodes:
+            if "__preql_internal" in node:
+                graph.remove_node(node)
+
+        if remove_isolates:
+            graph.remove_nodes_from(list(nx.isolates(graph)))
+
+        color_map = []
+        highlight_nodes = highlight_nodes or []
+        for node in graph:
+            if node in highlight_nodes:
+                color_map.append("orange")
+            elif str(node).startswith("ds"):
+                color_map.append("blue")
+            else:
+                color_map.append("green")
+
+        pos = nx.spring_layout(graph)
+        kwargs = {}
+
+        if target:
+            edge_colors = []
+            descendents = nx.descendants(graph, target)
+            for edge in graph.edges():
+                if edge[0] == target:
+                    edge_colors.append("blue")
+                elif edge[1] == target:
+                    edge_colors.append("blue")
+                elif edge[1] in descendents:
+                    edge_colors.append("green")
+                else:
+                    edge_colors.append("black")
+            kwargs["edge_color"] = edge_colors
+
+        # Draw the graph without labels first
+        nx.draw(
+            graph,
+            pos=pos,
+            node_color=color_map,
+            connectionstyle="arc3, rad = 0.1",
+            with_labels=False,  # Important: don't draw labels with nx.draw
+            **kwargs
+        )
+
+        # Draw labels with manual spacing
+        self._draw_labels_with_manual_spacing(graph, pos)
+
+        plt.show()
+
+    def _draw_labels_with_manual_spacing(self, graph, pos):
+        """Fallback method for manual label spacing when adjustText is not available"""
+        import numpy as np
+
+        pos_labels = {}
+        node_positions = list(pos.values())
+
+        # Calculate average distance between nodes to determine spacing
+        if len(node_positions) > 1:
+            distances = []
+            for i, (x1, y1) in enumerate(node_positions):
+                for j, (x2, y2) in enumerate(node_positions[i + 1 :], i + 1):
+                    dist = np.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
+                    distances.append(dist)
+
+            avg_distance = np.mean(distances)
+            min_spacing = max(
+                0.1, avg_distance * 0.3
+            )  # Minimum spacing as fraction of average distance
+        else:
+            min_spacing = 0.1
+
+        # Simple spacing algorithm - offset labels that are too close
+        for i, node in enumerate(graph.nodes()):
+            x, y = pos[node]
+
+            # Check for nearby labels and adjust position
+            adjusted_x, adjusted_y = x, y
+            for j, other_node in enumerate(
+                list(graph.nodes())[:i]
+            ):  # Only check previous nodes
+                other_x, other_y = pos_labels.get(other_node, pos[other_node])
+                distance = np.sqrt(
+                    (adjusted_x - other_x) ** 2 + (adjusted_y - other_y) ** 2
+                )
+
+                if distance < min_spacing:
+                    # Calculate offset direction
+                    if distance > 0:
+                        offset_x = (adjusted_x - other_x) / distance * min_spacing
+                        offset_y = (adjusted_y - other_y) / distance * min_spacing
+                    else:
+                        # If nodes are at exact same position, use random offset
+                        angle = np.random.random() * 2 * np.pi
+                        offset_x = np.cos(angle) * min_spacing
+                        offset_y = np.sin(angle) * min_spacing
+
+                    adjusted_x = other_x + offset_x
+                    adjusted_y = other_y + offset_y
+
+            pos_labels[node] = (adjusted_x, adjusted_y)
+
+        # Draw the labels at adjusted positions
+        nx.draw_networkx_labels(graph, pos=pos_labels, font_size=10)

{pytrilogy-0.0.3.61 → pytrilogy-0.0.3.64}/trilogy/parsing/common.py

@@ -86,7 +86,7 @@ def process_function_arg(
         if concept.metadata and meta:
             concept.metadata.line_number = meta.line
         environment.add_concept(concept, meta=meta)
-        return concept
+        return concept.reference
     elif isinstance(
         arg,
         (ListWrapper, MapWrapper),
@@ -103,7 +103,7 @@ def process_function_arg(
         if concept.metadata and meta:
             concept.metadata.line_number = meta.line
         environment.add_concept(concept, meta=meta)
-        return concept
+        return concept.reference
     elif isinstance(arg, Concept):
         return arg.reference
     elif isinstance(arg, ConceptRef):

{pytrilogy-0.0.3.61 → pytrilogy-0.0.3.64}/trilogy/parsing/render.py

@@ -506,7 +506,11 @@ class Renderer:
             return f"{args[0]} % {args[1]}"
         if arg.operator == FunctionType.PARENTHETICAL:
             return f"({args[0]})"
-
+        if arg.operator == FunctionType.GROUP:
+            arg_string = ", ".join(args[1:])
+            if len(args) == 1:
+                return f"group({args[0]})"
+            return f"group({args[0]}) by {arg_string}"
         inputs = ",".join(args)
 
         if arg.operator == FunctionType.CONSTANT: