pytrilogy 0.0.2.48__py3-none-any.whl → 0.0.2.50__py3-none-any.whl

trilogy/core/processing/utility.py

@@ -1,4 +1,5 @@
 from dataclasses import dataclass
+from datetime import date, datetime
 from enum import Enum
 from logging import Logger
 from typing import Any, Dict, List, Set, Tuple
@@ -214,7 +215,7 @@ def concept_to_relevant_joins(concepts: list[Concept]) -> List[Concept]:
             x for x in concepts if x.keys and all([key in addresses for key in x.keys])
         ]
     )
-    final = [c for c in concepts if c not in sub_props]
+    final = [c for c in concepts if c.address not in sub_props]
     return unique(final, "address")
 
 
@@ -380,6 +381,8 @@ def is_scalar_condition(
         int
         | str
         | float
+        | date
+        | datetime
         | list[Any]
         | WindowItem
         | FilterItem

trilogy/core/query_processor.py

@@ -7,7 +7,6 @@ from trilogy.core.constants import CONSTANT_DATASET
 from trilogy.core.enums import BooleanOperator, SourceType
 from trilogy.core.env_processor import generate_graph
 from trilogy.core.ergonomics import generate_cte_names
-from trilogy.core.graph_models import ReferenceGraph
 from trilogy.core.models import (
     CTE,
     BaseJoin,
@@ -353,13 +352,12 @@ def datasource_to_cte(
 def get_query_node(
     environment: Environment,
     statement: SelectStatement | MultiSelectStatement,
-    graph: Optional[ReferenceGraph] = None,
     history: History | None = None,
 ) -> StrategyNode:
     environment = environment.duplicate()
     for k, v in statement.local_concepts.items():
         environment.concepts[k] = v
-    graph = graph or generate_graph(environment)
+    graph = generate_graph(environment)
     logger.info(
         f"{LOGGER_PREFIX} getting source datasource for query with filtering {statement.where_clause_category} and output {[str(c) for c in statement.output_components]}"
     )
@@ -393,7 +391,6 @@ def get_query_node(
             input_concepts=ds.output_concepts,
             parents=[ds],
             environment=ds.environment,
-            g=ds.g,
             partial_concepts=ds.partial_concepts,
             conditions=final,
         )
@@ -403,11 +400,10 @@ def get_query_node(
 def get_query_datasources(
     environment: Environment,
     statement: SelectStatement | MultiSelectStatement,
-    graph: Optional[ReferenceGraph] = None,
     hooks: Optional[List[BaseHook]] = None,
 ) -> QueryDatasource:
 
-    ds = get_query_node(environment, statement, graph)
+    ds = get_query_node(environment, statement)
     final_qds = ds.resolve()
     if hooks:
         for hook in hooks:
@@ -479,10 +475,9 @@ def process_query(
     hooks: List[BaseHook] | None = None,
 ) -> ProcessedQuery:
     hooks = hooks or []
-    graph = generate_graph(environment)
 
     root_datasource = get_query_datasources(
-        environment=environment, graph=graph, statement=statement, hooks=hooks
+        environment=environment, statement=statement, hooks=hooks
     )
     for hook in hooks:
         hook.process_root_datasource(root_datasource)

trilogy/dialect/base.py

@@ -1,3 +1,4 @@
+from datetime import date, datetime
 from typing import Any, Callable, Dict, List, Optional, Sequence, Union
 
 from jinja2 import Template
@@ -102,13 +103,15 @@ WINDOW_FUNCTION_MAP = {
     WindowType.AVG: window_factory("avg", include_concept=True),
 }
 
-DATATYPE_MAP = {
+DATATYPE_MAP: dict[DataType, str] = {
     DataType.STRING: "string",
     DataType.INTEGER: "int",
     DataType.FLOAT: "float",
     DataType.BOOL: "bool",
     DataType.NUMERIC: "numeric",
     DataType.MAP: "map",
+    DataType.DATE: "date",
+    DataType.DATETIME: "datetime",
 }
 
 
@@ -131,6 +134,7 @@ FUNCTION_MAP = {
     FunctionType.SPLIT: lambda x: f"split({x[0]}, {x[1]})",
     FunctionType.IS_NULL: lambda x: f"isnull({x[0]})",
     FunctionType.BOOL: lambda x: f"CASE WHEN {x[0]} THEN TRUE ELSE FALSE END",
+    FunctionType.PARENTHETICAL: lambda x: f"({x[0]})",
     # Complex
     FunctionType.INDEX_ACCESS: lambda x: f"{x[0]}[{x[1]}]",
     FunctionType.MAP_ACCESS: lambda x: f"{x[0]}[{x[1]}][1]",
@@ -138,6 +142,8 @@ FUNCTION_MAP = {
     FunctionType.ATTR_ACCESS: lambda x: f"""{x[0]}.{x[1].replace("'", "")}""",
     FunctionType.STRUCT: lambda x: f"{{{', '.join(struct_arg(x))}}}",
     FunctionType.ARRAY: lambda x: f"[{', '.join(x)}]",
+    FunctionType.DATE_LITERAL: lambda x: f"date '{x}'",
+    FunctionType.DATETIME_LITERAL: lambda x: f"datetime '{x}'",
     # math
     FunctionType.ADD: lambda x: " + ".join(x),
     FunctionType.SUBTRACT: lambda x: " - ".join(x),
@@ -454,6 +460,8 @@ class BaseDialect:
             list,
             bool,
             float,
+            date,
+            datetime,
             DataType,
             Function,
             Parenthetical,
@@ -612,7 +620,7 @@ class BaseDialect:
         elif isinstance(e, list):
             return f"{self.FUNCTION_MAP[FunctionType.ARRAY]([self.render_expr(x, cte=cte, cte_map=cte_map, raise_invalid=raise_invalid) for x in e])}"
         elif isinstance(e, DataType):
-            return str(e.value)
+            return self.DATATYPE_MAP.get(e, e.value)
         elif isinstance(e, DatePart):
             return str(e.value)
         elif isinstance(e, NumericType):
@@ -620,6 +628,10 @@ class BaseDialect:
         elif isinstance(e, MagicConstants):
             if e == MagicConstants.NULL:
                 return "null"
+        elif isinstance(e, date):
+            return self.FUNCTION_MAP[FunctionType.DATE_LITERAL](e)
+        elif isinstance(e, datetime):
+            return self.FUNCTION_MAP[FunctionType.DATETIME_LITERAL](e)
         else:
             raise ValueError(f"Unable to render type {type(e)} {e}")
 

trilogy/dialect/duckdb.py

@@ -3,6 +3,7 @@ from typing import Any, Callable, Mapping
 from jinja2 import Template
 
 from trilogy.core.enums import FunctionType, UnnestMode, WindowType
+from trilogy.core.models import DataType
 from trilogy.dialect.base import BaseDialect
 
 WINDOW_FUNCTION_MAP: Mapping[WindowType, Callable[[Any, Any, Any], str]] = {}
@@ -30,6 +31,8 @@ FUNCTION_MAP = {
     FunctionType.DATE_PART: lambda x: f"date_part('{x[1]}', {x[0]})",
     FunctionType.DATE_DIFF: lambda x: f"date_diff('{x[2]}', {x[0]}, {x[1]})",
     FunctionType.CONCAT: lambda x: f"({' || '.join(x)})",
+    FunctionType.DATE_LITERAL: lambda x: f"date '{x}'",
+    FunctionType.DATETIME_LITERAL: lambda x: f"datetime '{x}'",
 }
 
 # if an aggregate function is called on a source that is at the same grain as the aggregate
@@ -44,6 +47,9 @@ FUNCTION_GRAIN_MATCH_MAP = {
     FunctionType.MIN: lambda args: f"{args[0]}",
 }
 
+DATATYPE_MAP: dict[DataType, str] = {}
+
+
 DUCKDB_TEMPLATE = Template(
     """{%- if output %}
 CREATE OR REPLACE TABLE {{ output.address.location }} AS
@@ -84,6 +90,7 @@ class DuckDBDialect(BaseDialect):
         **BaseDialect.FUNCTION_GRAIN_MATCH_MAP,
         **FUNCTION_GRAIN_MATCH_MAP,
     }
+    DATATYPE_MAP = {**BaseDialect.DATATYPE_MAP, **DATATYPE_MAP}
     QUOTE_CHARACTER = '"'
     SQL_TEMPLATE = DUCKDB_TEMPLATE
     UNNEST_MODE = UnnestMode.DIRECT

trilogy/hooks/graph_hook.py

@@ -1,7 +1,19 @@
+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):
@@ -11,6 +23,8 @@ class GraphHook(BaseHook):
         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,

trilogy/parsing/common.py

@@ -1,3 +1,4 @@
+from datetime import date, datetime
 from typing import List, Tuple
 
 from trilogy.constants import (
@@ -37,14 +38,22 @@ def process_function_args(
     args,
     meta: Meta | None,
     environment: Environment,
-):
-    final: List[Concept | Function] = []
+) -> List[Concept | Function | str | int | float | date | datetime]:
+    final: List[Concept | Function | str | int | float | date | datetime] = []
     for arg in args:
         # if a function has an anonymous function argument
         # create an implicit concept
-        while isinstance(arg, Parenthetical):
-            arg = arg.content
-        if isinstance(arg, Function):
+        if isinstance(arg, Parenthetical):
+            processed = process_function_args([arg.content], meta, environment)
+            final.append(
+                Function(
+                    operator=FunctionType.PARENTHETICAL,
+                    arguments=processed,
+                    output_datatype=arg_to_datatype(processed[0]),
+                    output_purpose=function_args_to_output_purpose(processed),
+                )
+            )
+        elif isinstance(arg, Function):
             # if it's not an aggregate function, we can skip the virtual concepts
             # to simplify anonymous function handling
             if (

trilogy/parsing/parse_engine.py

@@ -1,4 +1,5 @@
 from dataclasses import dataclass
+from datetime import date, datetime
 from os.path import dirname, join
 from pathlib import Path
 from re import IGNORECASE
@@ -570,6 +571,7 @@ class ParseToObjects(Transformer):
         for new_concept in output.derived_concepts:
             if new_concept.metadata:
                 new_concept.metadata.line_number = meta.line
+            # output.select.local_concepts[new_concept.address] = new_concept
             self.environment.add_concept(new_concept)
 
         return output
@@ -668,6 +670,12 @@ class ParseToObjects(Transformer):
         )
         for column in columns:
             column.concept = column.concept.with_grain(datasource.grain)
+        if datasource.where:
+            for x in datasource.where.concept_arguments:
+                if x.address not in datasource.output_concepts:
+                    raise ValueError(
+                        f"Datasource {name} where condition depends on concept {x.address} that does not exist on the datasource, line {meta.line}."
+                    )
         self.environment.add_datasource(datasource, meta=meta)
         return datasource
 
@@ -1782,6 +1790,30 @@ class ParseToObjects(Transformer):
     @v_args(meta=True)
     def fcast(self, meta, args) -> Function:
         args = process_function_args(args, meta=meta, environment=self.environment)
+        if isinstance(args[0], str):
+            processed: date | datetime | int | float | bool | str
+            if args[1] == DataType.DATE:
+                processed = date.fromisoformat(args[0])
+            elif args[1] == DataType.DATETIME:
+                processed = datetime.fromisoformat(args[0])
+            elif args[1] == DataType.TIMESTAMP:
+                processed = datetime.fromisoformat(args[0])
+            elif args[1] == DataType.INTEGER:
+                processed = int(args[0])
+            elif args[1] == DataType.FLOAT:
+                processed = float(args[0])
+            elif args[1] == DataType.BOOL:
+                processed = args[0].capitalize() == "True"
+            elif args[1] == DataType.STRING:
+                processed = args[0]
+            else:
+                raise SyntaxError(f"Invalid cast type {args[1]}")
+            return Function(
+                operator=FunctionType.CONSTANT,
+                output_datatype=args[1],
+                output_purpose=Purpose.CONSTANT,
+                arguments=[processed],
+            )
         output_datatype = args[1]
         return Function(
             operator=FunctionType.CAST,

trilogy/parsing/trilogy.lark

@@ -193,7 +193,9 @@
     _math_functions: fmul | fdiv | fadd | fsub | fround | fmod | fabs
     
     //generic
-    fcast: "cast"i "(" expr "as"i data_type ")"
+    _fcast_primary: "cast"i "(" expr "as"i data_type ")"
+    _fcast_alt: expr "::" data_type
+    fcast: _fcast_primary | _fcast_alt
     concat: ("concat"i "(" (expr ",")* expr ")") | (expr "||" expr)
     fcoalesce: "coalesce"i "(" (expr ",")* expr ")"
     fcase_when: "WHEN"i conditional "THEN"i expr