pytrilogy 0.0.2.58__py3-none-any.whl → 0.0.3.0__py3-none-any.whl

trilogy/executor.py

@@ -7,29 +7,29 @@ from sqlalchemy import text
 from sqlalchemy.engine import CursorResult, Engine
 
 from trilogy.constants import logger
-from trilogy.core.enums import Granularity, IOType
-from trilogy.core.models import (
-    Concept,
+from trilogy.core.enums import FunctionType, Granularity, IOType
+from trilogy.core.models.author import Concept, Function
+from trilogy.core.models.build import BuildConcept, BuildFunction
+from trilogy.core.models.core import ListWrapper, MapWrapper
+from trilogy.core.models.datasource import Datasource
+from trilogy.core.models.environment import Environment
+from trilogy.core.statements.author import (
     ConceptDeclarationStatement,
     CopyStatement,
-    Datasource,
-    Environment,
-    Function,
-    FunctionType,
     ImportStatement,
-    ListWrapper,
-    MapWrapper,
     MergeStatementV2,
     MultiSelectStatement,
     PersistStatement,
+    RawSQLStatement,
+    SelectStatement,
+    ShowStatement,
+)
+from trilogy.core.statements.execute import (
     ProcessedCopyStatement,
     ProcessedQuery,
     ProcessedQueryPersist,
     ProcessedRawSQLStatement,
     ProcessedShowStatement,
-    RawSQLStatement,
-    SelectStatement,
-    ShowStatement,
 )
 from trilogy.dialect.base import BaseDialect
 from trilogy.dialect.enums import Dialects
@@ -58,7 +58,9 @@ class MockResult:
         return self.columns
 
 
-def generate_result_set(columns: List[Concept], output_data: list[Any]) -> MockResult:
+def generate_result_set(
+    columns: List[BuildConcept], output_data: list[Any]
+) -> MockResult:
     names = [x.address.replace(".", "_") for x in columns]
     return MockResult(
         values=[dict(zip(names, [row])) for row in output_data], columns=names
@@ -394,6 +396,32 @@ class Executor(object):
             if persist and isinstance(x, ProcessedQueryPersist):
                 self.environment.add_datasource(x.datasource)
 
+    def _concept_to_value(
+        self,
+        concept: Concept,
+        local_concepts: dict[str, Concept] | None = None,
+    ) -> Any:
+        if not concept.granularity == Granularity.SINGLE_ROW:
+            raise SyntaxError(f"Cannot bind non-singleton concept {concept.address}")
+        # TODO: to get rid of function here - need to figure out why it's getting passed in
+        if (
+            isinstance(concept.lineage, (BuildFunction, Function))
+            and concept.lineage.operator == FunctionType.CONSTANT
+        ):
+            rval = concept.lineage.arguments[0]
+            if isinstance(rval, ListWrapper):
+                return [x for x in rval]
+            if isinstance(rval, MapWrapper):
+                return {k: v for k, v in rval.items()}
+            # if isinstance(rval, ConceptRef):
+            #     return self._concept_to_value(self.environment.concepts[rval.address], local_concepts=local_concepts)
+            return rval
+        else:
+            results = self.execute_query(f"select {concept.name} limit 1;").fetchone()
+        if not results:
+            return None
+        return results[0]
+
     def _hydrate_param(
         self, param: str, local_concepts: dict[str, Concept] | None = None
     ) -> Any:
@@ -412,23 +440,7 @@ class Executor(object):
             raise SyntaxError(f"No concept found for parameter {param}")
 
         concept: Concept = matched.pop()
-        if not concept.granularity == Granularity.SINGLE_ROW:
-            raise SyntaxError(f"Cannot bind non-singleton concept {concept.address}")
-        if (
-            isinstance(concept.lineage, Function)
-            and concept.lineage.operator == FunctionType.CONSTANT
-        ):
-            rval = concept.lineage.arguments[0]
-            if isinstance(rval, ListWrapper):
-                return [x for x in rval]
-            if isinstance(rval, MapWrapper):
-                return {k: v for k, v in rval.items()}
-            return rval
-        else:
-            results = self.execute_query(f"select {concept.name} limit 1;").fetchone()
-        if not results:
-            return None
-        return results[0]
+        return self._concept_to_value(concept, local_concepts=local_concepts)
 
     def execute_raw_sql(
         self,
@@ -437,7 +449,7 @@ class Executor(object):
         local_concepts: dict[str, Concept] | None = None,
     ) -> CursorResult:
         """Run a command against the raw underlying
-        execution engine"""
+        execution engine."""
         final_params = None
         q = text(command)
         if variables:
@@ -459,7 +471,7 @@ class Executor(object):
     def execute_text(
         self, command: str, non_interactive: bool = False
     ) -> List[CursorResult]:
-        """Run a preql text command"""
+        """Run a trilogy query expressed as text."""
         output = []
         # connection = self.engine.connect()
         for statement in self.parse_text_generator(command):

trilogy/hooks/base_hook.py

@@ -1,13 +1,15 @@
-from trilogy.core.models import (
+from trilogy.core.models.execute import (
     CTE,
+    QueryDatasource,
+    UnionCTE,
+)
+from trilogy.core.processing.nodes import StrategyNode
+from trilogy.core.statements.author import (
     MultiSelectStatement,
     PersistStatement,
-    QueryDatasource,
     RowsetDerivationStatement,
     SelectStatement,
-    UnionCTE,
 )
-from trilogy.core.processing.nodes import StrategyNode
 
 
 class BaseHook:

trilogy/hooks/query_debugger.py

@@ -1,16 +1,17 @@
 from enum import Enum
 from logging import DEBUG, StreamHandler
 from typing import Union
+from uuid import uuid4
 
 from trilogy.constants import logger
-from trilogy.core.models import (
+from trilogy.core.models.build import BuildDatasource
+from trilogy.core.models.execute import (
     CTE,
-    Datasource,
     QueryDatasource,
-    SelectStatement,
     UnionCTE,
 )
 from trilogy.core.processing.nodes import StrategyNode
+from trilogy.core.statements.author import SelectStatement
 from trilogy.dialect.bigquery import BigqueryDialect
 from trilogy.hooks.base_hook import BaseHook
 
@@ -24,90 +25,6 @@ class PrintMode(Enum):
 renderer = BigqueryDialect()
 
 
-def print_recursive_resolved(
-    input: Union[QueryDatasource, Datasource], mode: PrintMode, depth: int = 0
-):
-    extra = []
-    if isinstance(input, QueryDatasource):
-        if input.joins:
-            extra.append("join")
-        if input.condition:
-            extra.append("filter")
-    if input.group_required:
-        extra.append("group")
-    output = [c.address for c in input.output_concepts[:3]]
-    if len(input.output_concepts) > 3:
-        output.append("...")
-    display = [
-        (
-            "  " * depth,
-            input.__class__.__name__,
-            "<",
-            ",".join(extra),
-            ">",
-            # [c.address for c in input.input_concepts],
-            "->",
-            output,
-        )
-    ]
-    if isinstance(input, QueryDatasource):
-        for child in input.datasources:
-            display += print_recursive_resolved(child, mode=mode, depth=depth + 1)
-    return display
-
-
-def print_recursive_nodes(
-    input: StrategyNode, mode: PrintMode = PrintMode.BASIC, depth: int = 0
-):
-    resolved = input.resolve()
-    if mode == PrintMode.FULL:
-        display = [
-            [
-                "  " * depth,
-                input,
-                "->",
-                resolved.grain,
-                "->",
-                [c.address for c in resolved.output_concepts],
-            ]
-        ]
-    elif mode == PrintMode.BASIC:
-        display = [
-            [
-                "  " * depth,
-                input,
-                "->",
-                resolved.grain,
-            ]
-        ]
-    for child in input.parents:
-        display += print_recursive_nodes(
-            child,
-            mode=mode,
-            depth=depth + 1,
-        )
-    return display
-
-
-def print_recursive_ctes(
-    input: CTE | UnionCTE, depth: int = 0, max_depth: int | None = None
-):
-    if max_depth and depth > max_depth:
-        return
-    select_statement = [c.address for c in input.output_columns]
-    print("  " * depth, input.name, "->", input.group_to_grain, "->", select_statement)
-    sql = renderer.render_cte(input).statement
-    for line in sql.split("\n"):
-        logger.debug("  " * (depth) + line)
-    if isinstance(input, CTE):
-        for child in input.parent_ctes:
-            print_recursive_ctes(child, depth + 1)
-    elif isinstance(input, UnionCTE):
-        for child in input.parent_ctes:
-            for parent in child.parent_ctes:
-                print_recursive_ctes(parent, depth + 1)
-
-
 class DebuggingHook(BaseHook):
     def __init__(
         self,
@@ -127,24 +44,124 @@ class DebuggingHook(BaseHook):
         self.process_nodes = PrintMode(process_nodes)
         self.process_datasources = PrintMode(process_datasources)
         self.process_other = PrintMode(process_other)
+        self.messages: list[str] = []
+        self.uuid = uuid4()
+
+    def print(self, *args):
+        merged = " ".join([str(x) for x in args])
+        self.messages.append(merged)
+
+    def write(self):
+        with open(f"debug_{self.uuid}.log", "w") as f:
+            f.write("\n".join(self.messages))
 
     def process_select_info(self, select: SelectStatement):
         if self.process_datasources != PrintMode.OFF:
-            print(f"grain: {str(select.grain)}")
+            self.print(f"grain: {str(select.grain)}")
 
     def process_root_datasource(self, datasource: QueryDatasource):
         if self.process_datasources != PrintMode.OFF:
-            printed = print_recursive_resolved(datasource, self.process_datasources)
+            printed = self.print_recursive_resolved(
+                datasource, self.process_datasources
+            )
             for row in printed:
-                print("".join([str(v) for v in row]))
+                self.print("".join([str(v) for v in row]))
 
     def process_root_cte(self, cte: CTE | UnionCTE):
         if self.process_ctes != PrintMode.OFF:
-            print_recursive_ctes(cte, max_depth=self.max_depth)
+            self.print_recursive_ctes(cte, max_depth=self.max_depth)
 
     def process_root_strategy_node(self, node: StrategyNode):
         if self.process_nodes != PrintMode.OFF:
-            printed = print_recursive_nodes(node, mode=self.process_nodes)
+            printed = self.print_recursive_nodes(node, mode=self.process_nodes)
             for row in printed:
                 # logger.info("".join([str(v) for v in row]))
-                print("".join([str(v) for v in row]))
+                self.print("".join([str(v) for v in row]))
+
+    def print_recursive_resolved(
+        self,
+        input: Union[QueryDatasource, BuildDatasource],
+        mode: PrintMode,
+        depth: int = 0,
+    ):
+        extra = []
+        if isinstance(input, QueryDatasource):
+            if input.joins:
+                extra.append("join")
+            if input.condition:
+                extra.append("filter")
+        if input.group_required:
+            extra.append("group")
+        output = [c.address for c in input.output_concepts[:3]]
+        if len(input.output_concepts) > 3:
+            output.append("...")
+        display = [
+            (
+                "  " * depth,
+                input.__class__.__name__,
+                "<",
+                ",".join(extra),
+                ">",
+                # [c.address for c in input.input_concepts],
+                "->",
+                output,
+            )
+        ]
+        if isinstance(input, QueryDatasource):
+            for child in input.datasources:
+                display += self.print_recursive_resolved(
+                    child, mode=mode, depth=depth + 1
+                )
+        return display
+
+    def print_recursive_ctes(
+        self, input: CTE | UnionCTE, depth: int = 0, max_depth: int | None = None
+    ):
+        if max_depth and depth > max_depth:
+            return
+        select_statement = [c.address for c in input.output_columns]
+        self.print(
+            "  " * depth, input.name, "->", input.group_to_grain, "->", select_statement
+        )
+        sql = renderer.render_cte(input).statement
+        for line in sql.split("\n"):
+            logger.debug("  " * (depth) + line)
+        if isinstance(input, CTE):
+            for child in input.parent_ctes:
+                self.print_recursive_ctes(child, depth + 1)
+        elif isinstance(input, UnionCTE):
+            for child in input.parent_ctes:
+                for parent in child.parent_ctes:
+                    self.print_recursive_ctes(parent, depth + 1)
+
+    def print_recursive_nodes(
+        self, input: StrategyNode, mode: PrintMode = PrintMode.BASIC, depth: int = 0
+    ):
+        resolved = input.resolve()
+        if mode == PrintMode.FULL:
+            display = [
+                [
+                    "  " * depth,
+                    input,
+                    "->",
+                    resolved.grain,
+                    "->",
+                    [c.address for c in resolved.output_concepts],
+                ]
+            ]
+        elif mode == PrintMode.BASIC:
+            display = [
+                [
+                    "  " * depth,
+                    input,
+                    "->",
+                    resolved.grain,
+                ]
+            ]
+        for child in input.parents:
+            display += self.print_recursive_nodes(
+                child,
+                mode=mode,
+                depth=depth + 1,
+            )
+        return display

trilogy/parser.py

@@ -1,6 +1,6 @@
 from typing import Optional
 
-from trilogy.core.models import Environment
+from trilogy.core.models.environment import Environment
 from trilogy.parsing.parse_engine import parse_text