pytrilogy 0.0.3.68__tar.gz → 0.0.3.70__tar.gz

{pytrilogy-0.0.3.68/pytrilogy.egg-info → pytrilogy-0.0.3.70}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytrilogy
-Version: 0.0.3.68
+Version: 0.0.3.70
 Summary: Declarative, typed query language that compiles to SQL.
 Home-page: 
 Author: 
@@ -40,46 +40,61 @@ Dynamic: summary
 [![Website](https://img.shields.io/badge/INTRO-WEB-orange?)](https://trilogydata.dev/)
 [![Discord](https://img.shields.io/badge/DISCORD-CHAT-red?logo=discord)](https://discord.gg/Z4QSSuqGEd)
 
-pytrilogy is an experimental implementation of the Trilogy language, a higher-level SQL that replaces tables/joins with a lightweight semantic binding layer.
+The Trilogy language is an experiment in better SQL for analytics - a streamlined SQL that replaces tables/joins with a lightweight semantic binding layer and provides easy reuse and composability. It compiles to SQL - making it easy to debug or integrate into existing workflows - and can be run against any supported SQL backend.  
 
-Trilogy looks like SQL, but simpler. It's a modern SQL refresh targeted at SQL lovers who want more reusability and composability without losing the expressiveness and iterative value of SQL. It compiles to SQL - making it easy to debug or integrate into existing workflows - and can be run against any supported SQL backend.  
+[pytrilogy](https://github.com/trilogy-data/pytrilogy) is the reference implementation, written in Python.
+
+Trilogy concretely solves these common problems in karge, SQL based analytics teams:
+- decoupling consumption code from specific physical assets
+- better testability and change management
+- reduced boilerplate and opportunity for OLAP style optimization at scale
+
+Trilogy can be especially powerful as a frontend consumption language, since the decoupling from the physical layout makes dynamic and interactive dashboards backed by SQL tables much easier to create.
 
 > [!TIP]
-> Try it online in a hosted [open-source studio](https://trilogydata.dev/trilogy-studio-core/). To get an overview of the language and run interactive examples, head to the [documentation](https://trilogydata.dev/).
+> You can try Trilogy in a [open-source studio](https://trilogydata.dev/trilogy-studio-core/). More details on the language can be found on the [documentation](https://trilogydata.dev/).
 
-Installation: `pip install pytrilogy`
+We recommend the studio as the fastest way to explore Trilogy. For deeper work and integration, `pytrilogy` can be run locally to parse and execute trilogy model [.preql] files using the `trilogy` CLI tool, or can be run in python by importing the `trilogy` package.
 
-`pytrilogy` can be run locally to parse and execute trilogy model [.preql] files using the `trilogy` CLI tool, or can be run in python by importing the `trilogy` package.
+Installation: `pip install pytrilogy`
 
-You can read more about the project [here](https://trilogydata.dev/) and try out an interactive demo [here](https://trilogydata.dev/demo/). 
+### Trilogy Looks Like SQL
 
-Trilogy looks like SQL:
 ```sql
+import names;
+
+const top_names <- ['Elvis', 'Elvira', 'Elrond', 'Sam'];
+
+def initcap(word) -> upper(substring(word, 1, 1)) || substring(word, 2, len(word));
+
 WHERE 
-    name like '%lvis%'
+    @initcap(name) in top_names
 SELECT
     name,
-    count(name) as name_count
+    sum(births) as name_count
 ORDER BY
     name_count desc
 LIMIT 10;
 ```
 ## Goals
-And aims to:
+Versus SQL, Trilogy aims to: 
 
-Preserve:
+Keep:
 - Correctness
 - Accessibility
 
-Enhance:
+Improve:
 - Simplicity
-- Understandability
 - Refactoring/mantainability
 - Reusability
 
 Maintain:
 - Acceptable performance
 
+Remove:
+- Lower-level procedural features
+- Transactional optimizations/non-analytics features
+
 ## Hello World
 
 Save the following code in a file named `hello.preql`
@@ -141,10 +156,7 @@ SELECT
     sentences.text
 ;
 
-
-
 ```
-
 Run the following from the directory the file is in.
 
 ```bash
@@ -157,11 +169,15 @@ trilogy run hello.trilogy duckdb
 
 The current Trilogy implementation supports these backends:
 
+### Core
 - Bigquery
-- SQL Server
 - DuckDB
 - Snowflake
 
+### Experimental
+- SQL Server
+- Presto
+
 ## Basic Example - Python
 
 Trilogy can be run directly in python through the core SDK. Trilogy code can be defined and parsed inline or parsed out of files.
@@ -170,7 +186,6 @@ A bigquery example, similar to bigquery [the quickstart](https://cloud.google.co
 
 ```python
 
-
 from trilogy import Dialects, Environment
 
 environment = Environment()

{pytrilogy-0.0.3.68 → pytrilogy-0.0.3.70}/README.md

@@ -2,46 +2,61 @@
 [![Website](https://img.shields.io/badge/INTRO-WEB-orange?)](https://trilogydata.dev/)
 [![Discord](https://img.shields.io/badge/DISCORD-CHAT-red?logo=discord)](https://discord.gg/Z4QSSuqGEd)
 
-pytrilogy is an experimental implementation of the Trilogy language, a higher-level SQL that replaces tables/joins with a lightweight semantic binding layer.
+The Trilogy language is an experiment in better SQL for analytics - a streamlined SQL that replaces tables/joins with a lightweight semantic binding layer and provides easy reuse and composability. It compiles to SQL - making it easy to debug or integrate into existing workflows - and can be run against any supported SQL backend.  
 
-Trilogy looks like SQL, but simpler. It's a modern SQL refresh targeted at SQL lovers who want more reusability and composability without losing the expressiveness and iterative value of SQL. It compiles to SQL - making it easy to debug or integrate into existing workflows - and can be run against any supported SQL backend.  
+[pytrilogy](https://github.com/trilogy-data/pytrilogy) is the reference implementation, written in Python.
+
+Trilogy concretely solves these common problems in karge, SQL based analytics teams:
+- decoupling consumption code from specific physical assets
+- better testability and change management
+- reduced boilerplate and opportunity for OLAP style optimization at scale
+
+Trilogy can be especially powerful as a frontend consumption language, since the decoupling from the physical layout makes dynamic and interactive dashboards backed by SQL tables much easier to create.
 
 > [!TIP]
-> Try it online in a hosted [open-source studio](https://trilogydata.dev/trilogy-studio-core/). To get an overview of the language and run interactive examples, head to the [documentation](https://trilogydata.dev/).
+> You can try Trilogy in a [open-source studio](https://trilogydata.dev/trilogy-studio-core/). More details on the language can be found on the [documentation](https://trilogydata.dev/).
 
-Installation: `pip install pytrilogy`
+We recommend the studio as the fastest way to explore Trilogy. For deeper work and integration, `pytrilogy` can be run locally to parse and execute trilogy model [.preql] files using the `trilogy` CLI tool, or can be run in python by importing the `trilogy` package.
 
-`pytrilogy` can be run locally to parse and execute trilogy model [.preql] files using the `trilogy` CLI tool, or can be run in python by importing the `trilogy` package.
+Installation: `pip install pytrilogy`
 
-You can read more about the project [here](https://trilogydata.dev/) and try out an interactive demo [here](https://trilogydata.dev/demo/). 
+### Trilogy Looks Like SQL
 
-Trilogy looks like SQL:
 ```sql
+import names;
+
+const top_names <- ['Elvis', 'Elvira', 'Elrond', 'Sam'];
+
+def initcap(word) -> upper(substring(word, 1, 1)) || substring(word, 2, len(word));
+
 WHERE 
-    name like '%lvis%'
+    @initcap(name) in top_names
 SELECT
     name,
-    count(name) as name_count
+    sum(births) as name_count
 ORDER BY
     name_count desc
 LIMIT 10;
 ```
 ## Goals
-And aims to:
+Versus SQL, Trilogy aims to: 
 
-Preserve:
+Keep:
 - Correctness
 - Accessibility
 
-Enhance:
+Improve:
 - Simplicity
-- Understandability
 - Refactoring/mantainability
 - Reusability
 
 Maintain:
 - Acceptable performance
 
+Remove:
+- Lower-level procedural features
+- Transactional optimizations/non-analytics features
+
 ## Hello World
 
 Save the following code in a file named `hello.preql`
@@ -103,10 +118,7 @@ SELECT
     sentences.text
 ;
 
-
-
 ```
-
 Run the following from the directory the file is in.
 
 ```bash
@@ -119,11 +131,15 @@ trilogy run hello.trilogy duckdb
 
 The current Trilogy implementation supports these backends:
 
+### Core
 - Bigquery
-- SQL Server
 - DuckDB
 - Snowflake
 
+### Experimental
+- SQL Server
+- Presto
+
 ## Basic Example - Python
 
 Trilogy can be run directly in python through the core SDK. Trilogy code can be defined and parsed inline or parsed out of files.
@@ -132,7 +148,6 @@ A bigquery example, similar to bigquery [the quickstart](https://cloud.google.co
 
 ```python
 
-
 from trilogy import Dialects, Environment
 
 environment = Environment()

{pytrilogy-0.0.3.68 → pytrilogy-0.0.3.70/pytrilogy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytrilogy
-Version: 0.0.3.68
+Version: 0.0.3.70
 Summary: Declarative, typed query language that compiles to SQL.
 Home-page: 
 Author: 
@@ -40,46 +40,61 @@ Dynamic: summary
 [![Website](https://img.shields.io/badge/INTRO-WEB-orange?)](https://trilogydata.dev/)
 [![Discord](https://img.shields.io/badge/DISCORD-CHAT-red?logo=discord)](https://discord.gg/Z4QSSuqGEd)
 
-pytrilogy is an experimental implementation of the Trilogy language, a higher-level SQL that replaces tables/joins with a lightweight semantic binding layer.
+The Trilogy language is an experiment in better SQL for analytics - a streamlined SQL that replaces tables/joins with a lightweight semantic binding layer and provides easy reuse and composability. It compiles to SQL - making it easy to debug or integrate into existing workflows - and can be run against any supported SQL backend.  
 
-Trilogy looks like SQL, but simpler. It's a modern SQL refresh targeted at SQL lovers who want more reusability and composability without losing the expressiveness and iterative value of SQL. It compiles to SQL - making it easy to debug or integrate into existing workflows - and can be run against any supported SQL backend.  
+[pytrilogy](https://github.com/trilogy-data/pytrilogy) is the reference implementation, written in Python.
+
+Trilogy concretely solves these common problems in karge, SQL based analytics teams:
+- decoupling consumption code from specific physical assets
+- better testability and change management
+- reduced boilerplate and opportunity for OLAP style optimization at scale
+
+Trilogy can be especially powerful as a frontend consumption language, since the decoupling from the physical layout makes dynamic and interactive dashboards backed by SQL tables much easier to create.
 
 > [!TIP]
-> Try it online in a hosted [open-source studio](https://trilogydata.dev/trilogy-studio-core/). To get an overview of the language and run interactive examples, head to the [documentation](https://trilogydata.dev/).
+> You can try Trilogy in a [open-source studio](https://trilogydata.dev/trilogy-studio-core/). More details on the language can be found on the [documentation](https://trilogydata.dev/).
 
-Installation: `pip install pytrilogy`
+We recommend the studio as the fastest way to explore Trilogy. For deeper work and integration, `pytrilogy` can be run locally to parse and execute trilogy model [.preql] files using the `trilogy` CLI tool, or can be run in python by importing the `trilogy` package.
 
-`pytrilogy` can be run locally to parse and execute trilogy model [.preql] files using the `trilogy` CLI tool, or can be run in python by importing the `trilogy` package.
+Installation: `pip install pytrilogy`
 
-You can read more about the project [here](https://trilogydata.dev/) and try out an interactive demo [here](https://trilogydata.dev/demo/). 
+### Trilogy Looks Like SQL
 
-Trilogy looks like SQL:
 ```sql
+import names;
+
+const top_names <- ['Elvis', 'Elvira', 'Elrond', 'Sam'];
+
+def initcap(word) -> upper(substring(word, 1, 1)) || substring(word, 2, len(word));
+
 WHERE 
-    name like '%lvis%'
+    @initcap(name) in top_names
 SELECT
     name,
-    count(name) as name_count
+    sum(births) as name_count
 ORDER BY
     name_count desc
 LIMIT 10;
 ```
 ## Goals
-And aims to:
+Versus SQL, Trilogy aims to: 
 
-Preserve:
+Keep:
 - Correctness
 - Accessibility
 
-Enhance:
+Improve:
 - Simplicity
-- Understandability
 - Refactoring/mantainability
 - Reusability
 
 Maintain:
 - Acceptable performance
 
+Remove:
+- Lower-level procedural features
+- Transactional optimizations/non-analytics features
+
 ## Hello World
 
 Save the following code in a file named `hello.preql`
@@ -141,10 +156,7 @@ SELECT
     sentences.text
 ;
 
-
-
 ```
-
 Run the following from the directory the file is in.
 
 ```bash
@@ -157,11 +169,15 @@ trilogy run hello.trilogy duckdb
 
 The current Trilogy implementation supports these backends:
 
+### Core
 - Bigquery
-- SQL Server
 - DuckDB
 - Snowflake
 
+### Experimental
+- SQL Server
+- Presto
+
 ## Basic Example - Python
 
 Trilogy can be run directly in python through the core SDK. Trilogy code can be defined and parsed inline or parsed out of files.
@@ -170,7 +186,6 @@ A bigquery example, similar to bigquery [the quickstart](https://cloud.google.co
 
 ```python
 
-
 from trilogy import Dialects, Environment
 
 environment = Environment()

{pytrilogy-0.0.3.68 → pytrilogy-0.0.3.70}/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.68"
+__version__ = "0.0.3.70"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

{pytrilogy-0.0.3.68 → pytrilogy-0.0.3.70}/trilogy/core/functions.py

@@ -370,10 +370,10 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
         arg_count=2,
     ),
     FunctionType.REGEXP_EXTRACT: FunctionConfig(
-        valid_inputs={DataType.STRING},
+        valid_inputs=[{DataType.STRING}, {DataType.STRING}, {DataType.INTEGER}],
         output_purpose=Purpose.PROPERTY,
         output_type=DataType.STRING,
-        arg_count=2,
+        arg_count=3,
     ),
     FunctionType.REGEXP_REPLACE: FunctionConfig(
         valid_inputs={DataType.STRING},

{pytrilogy-0.0.3.68 → pytrilogy-0.0.3.70}/trilogy/core/models/author.py

@@ -2303,7 +2303,7 @@ class CustomFunctionFactory:
         ]
         return self
 
-    def __call__(self, *creation_args: list[Expr]):
+    def __call__(self, *creation_args: Expr):
         nout = (
             self.function.model_copy(deep=True)
             if isinstance(self.function, BaseModel)
@@ -2389,7 +2389,6 @@ Expr = (
     | int
     | str
     | float
-    | list
     | date
     | datetime
     | TupleWrapper
@@ -2430,7 +2429,6 @@ FuncArgs = (
     | ListType
     | MapType
     | NumericType
-    | list
     | ListWrapper[Any]
     | TupleWrapper[Any]
     | Comparison

{pytrilogy-0.0.3.68 → pytrilogy-0.0.3.70}/trilogy/core/models/build.py

@@ -155,6 +155,7 @@ def concepts_to_build_grain_concepts(
             pconcepts.append(c)
         elif environment:
             pconcepts.append(environment.concepts[c])
+
         else:
             raise ValueError(
                 f"Unable to resolve input {c} without environment provided to concepts_to_grain call"
@@ -248,7 +249,7 @@ def get_concept_arguments(expr) -> List["BuildConcept"]:
     return output
 
 
-class BuildParamaterizedConceptReference(BaseModel):
+class BuildParamaterizedConceptReference(DataTyped, BaseModel):
     concept: BuildConcept
 
     def __str__(self):
@@ -258,6 +259,10 @@ class BuildParamaterizedConceptReference(BaseModel):
     def safe_address(self) -> str:
         return self.concept.safe_address
 
+    @property
+    def output_datatype(self) -> DataType:
+        return self.concept.output_datatype
+
 
 class BuildGrain(BaseModel):
     components: set[str] = Field(default_factory=set)
@@ -1810,8 +1815,8 @@ class Factory:
             right_c, _ = self.instantiate_concept(base.right)
             right = right_c
         return BuildSubselectComparison.model_construct(
-            left=self.build(base.left),
-            right=self.build(right),
+            left=self.handle_constant(self.build(base.left)),
+            right=self.handle_constant(self.build(right)),
             operator=base.operator,
         )
 
@@ -1916,7 +1921,17 @@ class Factory:
         where_factory = Factory(
             grain=Grain(), environment=self.environment, local_concepts={}
         )
-
+        where_clause = (
+            where_factory.build(base.where_clause) if base.where_clause else None
+        )
+        # if the where clause derives new concepts
+        # we need to ensure these are accessible from the general factory
+        # post resolution
+        for bk, bv in where_factory.local_concepts.items():
+            # but do not override any local cahced grains
+            if bk in materialized:
+                continue
+            materialized[bk] = bv
         final: List[BuildConcept] = []
         for original in base.selection:
             new = original
@@ -1943,9 +1958,7 @@ class Factory:
                 factory.build(base.having_clause) if base.having_clause else None
             ),
             # this uses a different grain factory
-            where_clause=(
-                where_factory.build(base.where_clause) if base.where_clause else None
-            ),
+            where_clause=where_clause,
         )
 
     @build.register

{pytrilogy-0.0.3.68 → pytrilogy-0.0.3.70}/trilogy/core/processing/discovery_node_factory.py

@@ -469,6 +469,7 @@ def generate_node(
         Derivation.GROUP_TO: lambda: _generate_group_to_node(context),
         Derivation.BASIC: lambda: _generate_basic_node(context),
         Derivation.ROOT: lambda: RootNodeHandler(context).generate(),
+        Derivation.CONSTANT: lambda: RootNodeHandler(context).generate(),
     }
 
     handler = derivation_handlers.get(concept.derivation)

{pytrilogy-0.0.3.68 → pytrilogy-0.0.3.70}/trilogy/core/processing/node_generators/group_node.py

@@ -22,6 +22,24 @@ from trilogy.utility import unique
 LOGGER_PREFIX = "[GEN_GROUP_NODE]"
 
 
+def get_aggregate_grain(
+    concept: BuildConcept, environment: BuildEnvironment
+) -> BuildGrain:
+    parent_concepts: List[BuildConcept] = unique(
+        resolve_function_parent_concepts(concept, environment=environment), "address"
+    )
+    if (
+        concept.grain
+        and len(concept.grain.components) > 0
+        and not concept.grain.abstract
+    ):
+        grain_components = [environment.concepts[c] for c in concept.grain.components]
+        parent_concepts += grain_components
+        return BuildGrain.from_concepts(parent_concepts)
+    else:
+        return BuildGrain.from_concepts(parent_concepts)
+
+
 def gen_group_node(
     concept: BuildConcept,
     local_optional: List[BuildConcept],
@@ -51,7 +69,7 @@ def gen_group_node(
     ):
         grain_components = [environment.concepts[c] for c in concept.grain.components]
         parent_concepts += grain_components
-        build_grain_parents = BuildGrain.from_concepts(parent_concepts)
+        build_grain_parents = get_aggregate_grain(concept, environment)
         output_concepts += grain_components
         for possible_agg in local_optional:
 
@@ -70,6 +88,7 @@ def gen_group_node(
                     possible_agg,
                     environment=environment,
                 )
+                comp_grain = get_aggregate_grain(possible_agg, environment)
                 if set([x.address for x in agg_parents]).issubset(
                     set([x.address for x in parent_concepts])
                 ):
@@ -77,7 +96,7 @@ def gen_group_node(
                     logger.info(
                         f"{padding(depth)}{LOGGER_PREFIX} found equivalent group by optional concept {possible_agg.address} for {concept.address}"
                     )
-                elif BuildGrain.from_concepts(agg_parents) == build_grain_parents:
+                elif comp_grain == build_grain_parents:
                     extra = [x for x in agg_parents if x.address not in parent_concepts]
                     parent_concepts += extra
                     output_concepts.append(possible_agg)
@@ -86,7 +105,7 @@ def gen_group_node(
                     )
                 else:
                     logger.info(
-                        f"{padding(depth)}{LOGGER_PREFIX} cannot include optional agg {possible_agg.address}; mismatched parent grain {BuildGrain.from_concepts(agg_parents)} vs local parent {BuildGrain.from_concepts(parent_concepts)}"
+                        f"{padding(depth)}{LOGGER_PREFIX} cannot include optional agg {possible_agg.address}; it has mismatched parent grain {comp_grain } vs local parent {build_grain_parents}"
                     )
     if parent_concepts:
         logger.info(

{pytrilogy-0.0.3.68 → pytrilogy-0.0.3.70}/trilogy/core/processing/node_generators/select_merge_node.py

@@ -231,7 +231,10 @@ def create_pruned_concept_graph(
 
 
 def resolve_subgraphs(
-    g: nx.DiGraph, relevant: list[BuildConcept], conditions: BuildWhereClause | None
+    g: nx.DiGraph,
+    relevant: list[BuildConcept],
+    conditions: BuildWhereClause | None,
+    depth: int = 0,
 ) -> dict[str, list[str]]:
     """When we have multiple distinct subgraphs within our matched
     nodes that can satisfy a query, resolve which one of those we should
@@ -241,7 +244,7 @@ def resolve_subgraphs(
     discarding duplicates.
     Duplicate subgraphs will be resolved based on which
     ones are most 'optimal' to use, a hueristic
-    that can evolve in the future but is currently based on
+    that can evolve in the future but is currently based on datasource
     cardinality."""
     datasources = [n for n in g.nodes if n.startswith("ds~")]
     subgraphs: dict[str, list[str]] = {
@@ -261,7 +264,7 @@ def resolve_subgraphs(
     pruned_subgraphs = {}
 
     def score_node(input: str):
-        logger.debug(f"scoring node {input}")
+        logger.debug(f"{padding(depth)}{LOGGER_PREFIX} scoring node {input}")
         grain = grain_length[input]
         # first - go for lowest grain
         # but if the object we want is in the grain, treat that as "free"
@@ -275,7 +278,7 @@ def resolve_subgraphs(
             len(subgraphs[input]),
             input,
         )
-        logger.debug(score)
+        logger.debug(f"{padding(depth)}{LOGGER_PREFIX} node {input} has score {score}")
         return score
 
     for key, nodes in subgraphs.items():
@@ -296,7 +299,7 @@ def resolve_subgraphs(
                 if len(value) < len(other_value):
                     is_subset = True
                     logger.debug(
-                        f"Dropping subgraph {key} with {value} as it is a subset of {other_key} with {other_value}"
+                        f"{padding(depth)}{LOGGER_PREFIX} Dropping subgraph {key} with {value} as it is a subset of {other_key} with {other_value}"
                     )
                 elif len(value) == len(other_value) and len(all_concepts) == len(
                     other_all_concepts
@@ -305,7 +308,9 @@ def resolve_subgraphs(
                     matches.add(key)
         if matches and not is_subset:
             min_node = min(matches, key=score_node)
-            logger.debug(f"minimum source score is {min_node}")
+            logger.debug(
+                f"{padding(depth)}{LOGGER_PREFIX} minimum source score is {min_node}"
+            )
             is_subset = key is not min(matches, key=score_node)
         if not is_subset:
             pruned_subgraphs[key] = nodes
@@ -330,7 +335,9 @@ def resolve_subgraphs(
                 > 1
             )
         if not keep:
-            logger.debug(f"Pruning node {node} as irrelevant after subgraph resolution")
+            logger.debug(
+                f"{padding(depth)}{LOGGER_PREFIX} Pruning node {node} as irrelevant after subgraph resolution"
+            )
             pruned_subgraphs = {
                 k: [n for n in v if n != node] for k, v in pruned_subgraphs.items()
             }
@@ -561,7 +568,7 @@ def gen_select_merge_node(
         return None
 
     sub_nodes = resolve_subgraphs(
-        pruned_concept_graph, relevant=non_constant, conditions=conditions
+        pruned_concept_graph, relevant=non_constant, conditions=conditions, depth=depth
     )
 
     logger.info(f"{padding(depth)}{LOGGER_PREFIX} fetching subgraphs {sub_nodes}")

{pytrilogy-0.0.3.68 → pytrilogy-0.0.3.70}/trilogy/core/query_processor.py

@@ -395,14 +395,13 @@ def get_query_node(
     if not statement.output_components:
         raise ValueError(f"Statement has no output components {statement}")
     history = history or History(base_environment=environment)
-    print(
+    logger.info(
         f"{LOGGER_PREFIX} building query node for {statement.output_components} grain {statement.grain}"
     )
     build_statement: BuildSelectLineage | BuildMultiSelectLineage = Factory(
         environment=environment,
     ).build(statement)
 
-    # build_statement = statement
     build_environment = environment.materialize_for_select(
         build_statement.local_concepts
     )