pytrilogy 0.0.3.16__tar.gz → 0.0.3.18__tar.gz

{pytrilogy-0.0.3.16/pytrilogy.egg-info → pytrilogy-0.0.3.18}/PKG-INFO

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

{pytrilogy-0.0.3.16 → pytrilogy-0.0.3.18/pytrilogy.egg-info}/PKG-INFO

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

{pytrilogy-0.0.3.16 → pytrilogy-0.0.3.18}/tests/test_show.py

@@ -52,6 +52,6 @@ def test_show_bigquery():
         .execute_query(select)
         .fetchall()
     )
-    assert "FULL JOIN wakeful on 1=1" in query[0]["__preql_internal_query_text"], query[
-        0
-    ]["__preql_internal_query_text"]
+    assert (
+        "FULL JOIN cheerful on 1=1" in query[0]["__preql_internal_query_text"]
+    ), query[0]["__preql_internal_query_text"]

pytrilogy-0.0.3.18/tests/test_typing.py

@@ -0,0 +1,145 @@
+from decimal import Decimal
+
+from trilogy import Dialects
+
+
+def test_typing():
+    env = Dialects.DUCK_DB.default_executor()
+    env.environment.parse(
+        """
+
+type email string;
+
+key customer_id int;
+property customer_id.email string::email;
+
+def is_valid_email(email) -> contains(email, '@');
+
+datasource customers (
+    id:customer_id,
+    email: email
+)
+grain (customer_id)
+query '''
+select 1 as id, 'bright@gmail.com' as email
+union all
+select 2 as id, 'funky@hotmail.com' as email
+''';
+
+
+"""
+    )
+
+    results = env.execute_query(
+        """SELECT
+customer_id,
+@is_valid_email(email)->valid;"""
+    )
+
+    for row in results.fetchall():
+        assert row.valid is True
+
+    assert "email" in env.environment.data_types
+
+    assert env.environment.concepts["email"].datatype.traits == ["email"]
+
+
+def test_typing_aggregate():
+    env = Dialects.DUCK_DB.default_executor()
+    env.environment.parse(
+        """
+
+type money float;
+
+key revenue float::money;
+key revenue_two float::money;
+key multiplier float;
+
+datasource orders (
+    revenue:revenue,
+    revenue_two:revenue_two,
+    multiplier:multiplier
+)
+grain (revenue)
+query '''
+select 5.0 as revenue, 3.3 as revenue_two, 2.0 as multiplier
+union all
+select 10.0 as revenue, 13.1 as revenue_two, 3.0 as multiplier
+''';
+
+
+"""
+    )
+
+    results = env.execute_query(
+        """SELECT
+sum(revenue)->direct_total,
+sum(revenue*multiplier)->total,
+direct_total-total -> diff;"""
+    )
+
+    for row in results.fetchall():
+        assert row.total == Decimal("40.00")
+
+    assert "money" in env.environment.data_types
+    assert env.environment.concepts["direct_total"].datatype.traits == ["money"]
+    assert env.environment.concepts["total"].datatype.traits == ["money"]
+    assert env.environment.concepts["diff"].datatype.traits == [
+        "money"
+    ], env.environment.concepts["diff"].datatype
+
+    results = env.execute_query(
+        """SELECT
+revenue+revenue_two->add_total,
+revenue-revenue_two->sub_total
+;"""
+    )
+
+    assert "money" in env.environment.data_types
+    assert env.environment.concepts["add_total"].datatype.traits == ["money"]
+    assert env.environment.concepts["sub_total"].datatype.traits == ["money"]
+
+
+def test_custom_function_typing():
+    env = Dialects.DUCK_DB.default_executor()
+    env.environment.parse(
+        """
+
+type money float;
+
+key revenue float::money;
+
+def revenue_times_2(revenue) -> revenue*2;
+
+def revenue_times_multiplier(revenue, multiplier) -> revenue*multiplier;
+
+datasource orders (
+    revenue:revenue,
+
+)
+grain (revenue)
+query '''
+select 5.0 as revenue, 3.3 as revenue_two, 2.0 as multiplier
+union all
+select 10.0 as revenue, 13.1 as revenue_two, 3.0 as multiplier
+''';
+
+
+"""
+    )
+
+    _ = env.execute_query(
+        """
+with scaled as
+SELECT
+    @revenue_times_2(revenue)->revenue
+;
+        
+SELECT
+sum(
+    round( @revenue_times_multiplier(lag 1 @revenue_times_2(scaled.revenue), 2.0), 2)
+)->total;
+"""
+    )
+
+    assert env.environment.concepts["total"].datatype.traits == ["money"]

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

{pytrilogy-0.0.3.16 → pytrilogy-0.0.3.18}/trilogy/authoring/__init__.py

@@ -40,6 +40,7 @@ from trilogy.core.models.core import (
     MapType,
     StructType,
 )
+from trilogy.core.models.datasource import Datasource, DatasourceMetadata
 from trilogy.core.models.environment import Environment
 from trilogy.core.statements.author import (
     ConceptDeclarationStatement,
@@ -100,4 +101,6 @@ __all__ = [
     "MultiSelectStatement",
     "PersistStatement",
     "RawSQLStatement",
+    "Datasource",
+    "DatasourceMetadata",
 ]

{pytrilogy-0.0.3.16 → pytrilogy-0.0.3.18}/trilogy/core/enums.py

@@ -193,6 +193,7 @@ class FunctionType(Enum):
     DATE_PART = "date_part"
     DATE_TRUNCATE = "date_truncate"
     DATE_ADD = "date_add"
+    DATE_SUB = "date_sub"
     DATE_DIFF = "date_diff"
 
     # UNIX

{pytrilogy-0.0.3.16 → pytrilogy-0.0.3.18}/trilogy/core/ergonomics.py

@@ -3,7 +3,6 @@ from trilogy.constants import CONFIG
 # source: https://github.com/aaronbassett/Pass-phrase
 CTE_NAMES = """quizzical
 highfalutin
-dynamic
 wakeful
 cheerful
 thoughtful

{pytrilogy-0.0.3.16 → pytrilogy-0.0.3.18}/trilogy/core/functions.py

@@ -29,6 +29,7 @@ from trilogy.core.models.core import (
     MapType,
     NumericType,
     StructType,
+    TraitDataType,
     arg_to_datatype,
     merge_datatypes,
 )
@@ -94,6 +95,10 @@ def get_cast_output_type(
     return args[1]
 
 
+def get_output_type_at_index(args, index: int):
+    return arg_to_datatype(args[index])
+
+
 def validate_case_output(
     args: list[Any],
 ) -> DataType:
@@ -140,6 +145,12 @@ def get_date_trunc_output(
 
 
 FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
+    FunctionType.ALIAS: FunctionConfig(
+        arg_count=1,
+    ),
+    FunctionType.PARENTHETICAL: FunctionConfig(
+        arg_count=1,
+    ),
     FunctionType.UNNEST: FunctionConfig(
         valid_inputs={
             DataType.ARRAY,
@@ -173,7 +184,6 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
             DataType.BOOL,
         },
         output_purpose=Purpose.METRIC,
-        output_type=DataType.INTEGER,
         arg_count=1,
     ),
     FunctionType.MIN: FunctionConfig(
@@ -186,7 +196,6 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
             DataType.TIMESTAMP,
         },
         output_purpose=Purpose.METRIC,
-        output_type=DataType.INTEGER,
         arg_count=1,
     ),
     FunctionType.SPLIT: FunctionConfig(
@@ -237,7 +246,6 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
     FunctionType.ABS: FunctionConfig(
         valid_inputs={DataType.INTEGER, DataType.FLOAT, DataType.NUMBER},
         output_purpose=Purpose.PROPERTY,
-        output_type=DataType.INTEGER,
         arg_count=1,
     ),
     FunctionType.COALESCE: FunctionConfig(
@@ -370,6 +378,21 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
         output_type=DataType.DATE,
         arg_count=3,
     ),
+    FunctionType.DATE_SUB: FunctionConfig(
+        valid_inputs=[
+            {
+                DataType.DATE,
+                DataType.TIMESTAMP,
+                DataType.DATETIME,
+                DataType.STRING,
+            },
+            {DataType.DATE_PART},
+            {DataType.INTEGER},
+        ],
+        output_purpose=Purpose.PROPERTY,
+        output_type=DataType.DATE,
+        arg_count=3,
+    ),
     FunctionType.DATE_DIFF: FunctionConfig(
         valid_inputs=[
             {
@@ -519,7 +542,6 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
             DataType.NUMERIC,
         },
         output_purpose=Purpose.PROPERTY,
-        output_type=DataType.INTEGER,
         arg_count=InfiniteFunctionArgs,
     ),
     FunctionType.SUBTRACT: FunctionConfig(
@@ -530,7 +552,6 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
             DataType.NUMERIC,
         },
         output_purpose=Purpose.PROPERTY,
-        output_type=DataType.INTEGER,
         arg_count=InfiniteFunctionArgs,
     ),
     FunctionType.MULTIPLY: FunctionConfig(
@@ -541,7 +562,6 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
             DataType.NUMERIC,
         },
         output_purpose=Purpose.PROPERTY,
-        output_type=DataType.INTEGER,
         arg_count=InfiniteFunctionArgs,
     ),
     FunctionType.DIVIDE: FunctionConfig(
@@ -552,7 +572,6 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
             DataType.NUMERIC,
         },
         output_purpose=Purpose.PROPERTY,
-        output_type=DataType.INTEGER,
         arg_count=InfiniteFunctionArgs,
     ),
     FunctionType.MOD: FunctionConfig(
@@ -570,7 +589,7 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
             {DataType.INTEGER},
         ],
         output_purpose=Purpose.PROPERTY,
-        output_type=DataType.INTEGER,
+        output_type_function=lambda args: get_output_type_at_index(args, 0),
         arg_count=2,
     ),
     FunctionType.CUSTOM: FunctionConfig(
@@ -621,13 +640,11 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
     FunctionType.SUM: FunctionConfig(
         valid_inputs={DataType.INTEGER, DataType.FLOAT, DataType.NUMBER},
         output_purpose=Purpose.METRIC,
-        output_type=DataType.INTEGER,
         arg_count=1,
     ),
     FunctionType.AVG: FunctionConfig(
         valid_inputs={DataType.INTEGER, DataType.FLOAT, DataType.NUMBER},
         output_purpose=Purpose.METRIC,
-        output_type=DataType.INTEGER,
         arg_count=1,
     ),
     FunctionType.UNIX_TO_TIMESTAMP: FunctionConfig(
@@ -640,8 +657,6 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
 
 EXCLUDED_FUNCTIONS = {
     FunctionType.CUSTOM,
-    FunctionType.ALIAS,
-    FunctionType.PARENTHETICAL,
     # Temporary
     FunctionType.DATE_LITERAL,
     FunctionType.DATETIME_LITERAL,
@@ -650,7 +665,9 @@ EXCLUDED_FUNCTIONS = {
 
 for k in FunctionType.__members__.values():
     if k not in FUNCTION_REGISTRY and k not in EXCLUDED_FUNCTIONS:
-        raise InvalidSyntaxException(f"Function {k} not in registry")
+        raise InvalidSyntaxException(
+            f"Function enum value {k} not in creation registry"
+        )
 
 
 class FunctionFactory:
@@ -686,8 +703,10 @@ class FunctionFactory:
             full_args = []
         final_output_type: CONCRETE_TYPES
         if config.output_type_function:
+
             final_output_type = config.output_type_function(full_args)
         elif not base_output_type:
+
             final_output_type = merge_datatypes([arg_to_datatype(x) for x in full_args])
         elif base_output_type:
             final_output_type = base_output_type
@@ -715,7 +734,7 @@ def create_function_derived_concept(
     operator: FunctionType,
     arguments: list[Concept],
     output_type: Optional[
-        DataType | ListType | StructType | MapType | NumericType
+        DataType | ListType | StructType | MapType | NumericType | TraitDataType
     ] = None,
     output_purpose: Optional[Purpose] = None,
 ) -> Concept:

{pytrilogy-0.0.3.16 → pytrilogy-0.0.3.18}/trilogy/core/models/author.py

@@ -793,6 +793,10 @@ class Concept(Addressable, DataTyped, ConceptArgs, Mergeable, Namespaced, BaseMo
         base = f"{self.address}@{self.grain}"
         return base
 
+    @property
+    def is_internal(self) -> bool:
+        return self.namespace.startswith("_") or self.name.startswith("_")
+
     @property
     def reference(self) -> ConceptRef:
         return ConceptRef.model_construct(
@@ -1370,7 +1374,7 @@ class WindowItem(DataTyped, ConceptArgs, Mergeable, Namespaced, BaseModel):
 
 
 def get_basic_type(
-    type: DataType | ListType | StructType | MapType | NumericType,
+    type: DataType | ListType | StructType | MapType | NumericType | TraitDataType,
 ) -> DataType:
     if isinstance(type, ListType):
         return DataType.LIST
@@ -1380,6 +1384,8 @@ def get_basic_type(
         return DataType.MAP
     if isinstance(type, NumericType):
         return DataType.NUMERIC
+    if isinstance(type, TraitDataType):
+        return type.type
     return type
 
 
@@ -1531,7 +1537,9 @@ def get_concept_arguments(expr) -> List["ConceptRef"]:
 class Function(DataTyped, ConceptArgs, Mergeable, Namespaced, BaseModel):
     operator: FunctionType
     arg_count: int = Field(default=1)
-    output_datatype: DataType | ListType | StructType | MapType | NumericType
+    output_datatype: (
+        DataType | ListType | StructType | MapType | NumericType | TraitDataType
+    )
     output_purpose: Purpose
     valid_inputs: Optional[
         Union[
@@ -1629,23 +1637,30 @@ class Function(DataTyped, ConceptArgs, Mergeable, Namespaced, BaseModel):
         return v
 
     def with_reference_replacement(self, source: str, target: Expr):
+        from trilogy.core.functions import arg_to_datatype, merge_datatypes
+
+        nargs = [
+            (
+                c.with_reference_replacement(
+                    source,
+                    target,
+                )
+                if isinstance(
+                    c,
+                    Mergeable,
+                )
+                else c
+            )
+            for c in self.arguments
+        ]
+        if self.output_datatype == DataType.UNKNOWN:
+            new_output = merge_datatypes([arg_to_datatype(x) for x in nargs])
+        else:
+            new_output = self.output_datatype
         return Function.model_construct(
             operator=self.operator,
-            arguments=[
-                (
-                    c.with_reference_replacement(
-                        source,
-                        target,
-                    )
-                    if isinstance(
-                        c,
-                        Mergeable,
-                    )
-                    else c
-                )
-                for c in self.arguments
-            ],
-            output_datatype=self.output_datatype,
+            arguments=nargs,
+            output_datatype=new_output,
             output_purpose=self.output_purpose,
             valid_inputs=self.valid_inputs,
             arg_count=self.arg_count,
@@ -1777,7 +1792,7 @@ class AggregateWrapper(Mergeable, DataTyped, ConceptArgs, Namespaced, BaseModel)
         )
 
 
-class FilterItem(Namespaced, ConceptArgs, BaseModel):
+class FilterItem(DataTyped, Namespaced, ConceptArgs, BaseModel):
     content: ConceptRef
     where: "WhereClause"
 
@@ -1837,7 +1852,7 @@ class RowsetLineage(Namespaced, Mergeable, BaseModel):
         )
 
 
-class RowsetItem(Mergeable, ConceptArgs, Namespaced, BaseModel):
+class RowsetItem(Mergeable, DataTyped, ConceptArgs, Namespaced, BaseModel):
     content: ConceptRef
     rowset: RowsetLineage
 

{pytrilogy-0.0.3.16 → pytrilogy-0.0.3.18}/trilogy/core/models/core.py

@@ -51,7 +51,13 @@ class Addressable(ABC):
 
 
 TYPEDEF_TYPES = Union[
-    "DataType", "MapType", "ListType", "NumericType", "StructType", "DataTyped"
+    "DataType",
+    "MapType",
+    "ListType",
+    "NumericType",
+    "StructType",
+    "DataTyped",
+    "TraitDataType",
 ]
 
 CONCRETE_TYPES = Union[
@@ -60,6 +66,7 @@ CONCRETE_TYPES = Union[
     "ListType",
     "NumericType",
     "StructType",
+    "TraitDataType",
 ]
 
 KT = TypeVar("KT")
@@ -101,6 +108,16 @@ class TraitDataType(BaseModel):
     type: DataType
     traits: list[str]
 
+    def __hash__(self):
+        return hash(self.type)
+
+    def __eq__(self, other):
+        if isinstance(other, DataType):
+            return self.type == other
+        elif isinstance(other, TraitDataType):
+            return self.type == other.type and self.traits == other.traits
+        return False
+
     @property
     def data_type(self):
         return self.type
@@ -312,8 +329,10 @@ def dict_to_map_wrapper(arg):
 
 
 def merge_datatypes(
-    inputs: list[DataType | ListType | StructType | MapType | NumericType],
-) -> DataType | ListType | StructType | MapType | NumericType:
+    inputs: list[
+        DataType | ListType | StructType | MapType | NumericType | TraitDataType
+    ],
+) -> DataType | ListType | StructType | MapType | NumericType | TraitDataType:
     """This is a temporary hack for doing between
     allowable datatype transformation matrix"""
     if len(inputs) == 1:
@@ -348,6 +367,7 @@ def is_compatible_datatype(left, right):
 
 
 def arg_to_datatype(arg) -> CONCRETE_TYPES:
+
     if isinstance(arg, MagicConstants):
         if arg == MagicConstants.NULL:
             return DataType.NULL

{pytrilogy-0.0.3.16 → pytrilogy-0.0.3.18}/trilogy/core/models/environment.py

@@ -58,6 +58,7 @@ if TYPE_CHECKING:
 class Import:
     alias: str
     path: Path
+    input_path: str | None = None
 
 
 class BaseImportResolver(BaseModel):

{pytrilogy-0.0.3.16 → pytrilogy-0.0.3.18}/trilogy/core/statements/author.py

@@ -134,7 +134,6 @@ class SelectStatement(HasUUID, SelectTypeMixin, BaseModel):
         output.grain = output.calculate_grain(environment)
 
         for x in selection:
-
             if x.is_undefined and environment.concepts.fail_on_missing:
                 environment.concepts.raise_undefined(
                     x.concept.address, meta.line_number if meta else None
@@ -158,7 +157,6 @@ class SelectStatement(HasUUID, SelectTypeMixin, BaseModel):
                 output.local_concepts[x.content.address] = environment.concepts[
                     x.content.address
                 ]  # .set_select_grain(output.grain, environment)
-
         output.validate_syntax(environment)
         return output
 
@@ -384,7 +382,12 @@ class MergeStatementV2(HasUUID, BaseModel):
 
 
 class ImportStatement(HasUUID, BaseModel):
+    # import abc.def as bar
+    # the bit after 'as', eg bar
     alias: str
+    # the bit after import, abc.def
+    input_path: str
+    # what it actually resolves to, typically a filepath
     path: Path
 
 

{pytrilogy-0.0.3.16 → pytrilogy-0.0.3.18}/trilogy/dialect/duckdb.py

@@ -8,6 +8,7 @@ from trilogy.dialect.base import BaseDialect
 
 WINDOW_FUNCTION_MAP: Mapping[WindowType, Callable[[Any, Any, Any], str]] = {}
 
+
 FUNCTION_MAP = {
     FunctionType.COUNT: lambda args: f"count({args[0]})",
     FunctionType.SUM: lambda args: f"sum({args[0]})",
@@ -27,7 +28,7 @@ FUNCTION_MAP = {
     # datetime is aliased
     FunctionType.CURRENT_DATETIME: lambda x: "cast(get_current_timestamp() as datetime)",
     FunctionType.DATE_TRUNCATE: lambda x: f"date_trunc('{x[1]}', {x[0]})",
-    FunctionType.DATE_ADD: lambda x: f"date_add({x[0]}, INTERVAL {x[2]} {x[1]})",
+    FunctionType.DATE_ADD: lambda x: f"date_add({x[0]}, {x[2]} * INTERVAL 1 {x[1]})",
     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)})",

{pytrilogy-0.0.3.16 → pytrilogy-0.0.3.18}/trilogy/parsing/common.py

@@ -100,6 +100,8 @@ def process_function_arg(
             concept.metadata.line_number = meta.line
         environment.add_concept(concept, meta=meta)
         return concept
+    elif isinstance(arg, ConceptRef):
+        return environment.concepts[arg.address]
     return arg
 
 
@@ -192,6 +194,8 @@ def concept_is_relevant(
 ) -> bool:
     if isinstance(concept, UndefinedConcept):
 
+        return False
+    if concept.datatype == DataType.UNKNOWN:
         return False
     if isinstance(concept, ConceptRef):
         if environment: