pytrilogy 0.0.3.100__tar.gz → 0.0.3.102__tar.gz

{pytrilogy-0.0.3.100/pytrilogy.egg-info → pytrilogy-0.0.3.102}/PKG-INFO

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

{pytrilogy-0.0.3.100 → pytrilogy-0.0.3.102/pytrilogy.egg-info}/PKG-INFO

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

{pytrilogy-0.0.3.100 → pytrilogy-0.0.3.102}/pytrilogy.egg-info/SOURCES.txt

@@ -34,6 +34,7 @@ tests/test_statements.py
 tests/test_typing.py
 tests/test_undefined_concept.py
 tests/test_user_functions.py
+tests/test_validators.py
 tests/test_where_clause.py
 trilogy/__init__.py
 trilogy/constants.py

{pytrilogy-0.0.3.100 → pytrilogy-0.0.3.102}/tests/test_parsing.py

@@ -552,7 +552,7 @@ const labels <- '';
 
 def test_struct_attr_access():
     text = """
-const labels <- struct(a->1, b->2, c->3);
+const labels <- struct(1->a, 2->b, 3->c);
 
 
 select

pytrilogy-0.0.3.102/tests/test_validators.py

@@ -0,0 +1,209 @@
+from datetime import date, datetime
+from decimal import Decimal
+
+from trilogy.core.models.core import (
+    ArrayType,
+    DataType,
+    MapType,
+    NumericType,
+    StructType,
+    TraitDataType,
+)
+from trilogy.core.validation.datasource import type_check
+
+
+def test_type_check():
+    # Basic string tests
+    assert type_check("hello", DataType.STRING)
+    assert not type_check(123, DataType.STRING)
+    assert type_check("", DataType.STRING)  # empty string
+
+    # Integer tests
+    assert type_check(123, DataType.INTEGER)
+    assert type_check(0, DataType.INTEGER)
+    assert type_check(-123, DataType.INTEGER)
+    assert not type_check("123", DataType.INTEGER)
+    assert not type_check(123.0, DataType.INTEGER)  # float should not match int
+
+    # BIGINT tests (same as INTEGER in implementation)
+    assert type_check(123, DataType.BIGINT)
+    assert type_check(2**63 - 1, DataType.BIGINT)  # large integer
+    assert not type_check("123", DataType.BIGINT)
+    assert not type_check(123.0, DataType.BIGINT)
+
+    # Float tests
+    assert type_check(123.45, DataType.FLOAT)
+    assert type_check(123, DataType.FLOAT)  # int should match float
+    assert type_check(0.0, DataType.FLOAT)
+    assert type_check(-123.45, DataType.FLOAT)
+    assert not type_check("123.45", DataType.FLOAT)
+
+    # Decimal support in float
+    decimal_val = Decimal("123.45")
+    assert type_check(decimal_val, DataType.FLOAT)
+
+    # NumericType tests
+    numeric_type = NumericType()  # Assuming NumericType can be instantiated
+    assert type_check(123.45, numeric_type)
+    assert type_check(123, numeric_type)
+    assert type_check(decimal_val, numeric_type)
+    assert not type_check("123", numeric_type)
+
+    # NUMBER and NUMERIC tests (both handle int, float, Decimal)
+    assert type_check(123, DataType.NUMBER)
+    assert type_check(123.45, DataType.NUMBER)
+    assert type_check(decimal_val, DataType.NUMBER)
+    assert not type_check("123", DataType.NUMBER)
+
+    assert type_check(123, DataType.NUMERIC)
+    assert type_check(123.45, DataType.NUMERIC)
+    assert type_check(decimal_val, DataType.NUMERIC)
+    assert not type_check("123", DataType.NUMERIC)
+
+    # Boolean tests
+    assert type_check(True, DataType.BOOL)
+    assert type_check(False, DataType.BOOL)
+    assert not type_check(1, DataType.BOOL)  # int should not match bool
+    assert not type_check(0, DataType.BOOL)
+    assert not type_check("true", DataType.BOOL)
+
+    # Date tests
+    test_date = date(2023, 12, 25)
+    assert type_check(test_date, DataType.DATE)
+    assert not type_check("2023-12-25", DataType.DATE)
+    assert not type_check(
+        datetime.now(), DataType.DATE
+    )  # datetime should not match date
+
+    # DateTime and Timestamp tests
+    test_datetime = datetime(2023, 12, 25, 15, 30, 45)
+    assert type_check(test_datetime, DataType.DATETIME)
+    assert type_check(test_datetime, DataType.TIMESTAMP)
+    assert not type_check("2023-12-25 15:30:45", DataType.DATETIME)
+    assert not type_check(
+        test_date, DataType.DATETIME
+    )  # date should not match datetime
+
+    # Unix seconds tests
+    assert type_check(1640995200, DataType.UNIX_SECONDS)  # int timestamp
+    assert type_check(1640995200.123, DataType.UNIX_SECONDS)  # float timestamp
+    assert not type_check("1640995200", DataType.UNIX_SECONDS)
+
+    # Date part tests
+    assert type_check("year", DataType.DATE_PART)
+    assert type_check("month", DataType.DATE_PART)
+    assert type_check("day", DataType.DATE_PART)
+    assert not type_check(2023, DataType.DATE_PART)
+
+    # Array tests
+    assert type_check([1, 2, 3], DataType.ARRAY)
+    assert type_check([], DataType.ARRAY)  # empty array
+    assert type_check(["a", "b"], DataType.ARRAY)
+    assert not type_check("not a list", DataType.ARRAY)
+    assert not type_check({"key": "value"}, DataType.ARRAY)
+
+    # ArrayType tests
+    array_type = ArrayType(type=DataType.INTEGER)
+    assert type_check([1, 2, 3], array_type)
+    assert not type_check("not a list", array_type)
+
+    # Map tests
+    assert type_check({"key": "value"}, DataType.MAP)
+    assert type_check({}, DataType.MAP)  # empty dict
+    assert type_check({"a": 1, "b": 2}, DataType.MAP)
+    assert not type_check([1, 2, 3], DataType.MAP)
+    assert not type_check("not a dict", DataType.MAP)
+
+    # MapType tests
+    map_type = MapType(key_type=DataType.STRING, value_type=DataType.STRING)
+    assert type_check({"key": "value"}, map_type)
+    assert not type_check([1, 2, 3], map_type)
+
+    # Struct tests
+    assert type_check({"field1": "value1"}, DataType.STRUCT)
+    assert type_check({}, DataType.STRUCT)
+    assert not type_check([1, 2, 3], DataType.STRUCT)
+
+    # StructType tests
+    struct_type = StructType(
+        fields=[DataType.STRING, DataType.STRING],
+        fields_map={"field1": DataType.STRING, "field2": DataType.STRING},
+    )
+    assert not type_check("not a dict", struct_type)
+
+    # NULL tests
+    assert type_check(None, DataType.NULL)
+    assert not type_check("", DataType.NULL)
+    assert not type_check(0, DataType.NULL)
+    assert not type_check(False, DataType.NULL)
+
+    # UNKNOWN tests (should accept anything)
+    assert type_check("anything", DataType.UNKNOWN)
+    assert type_check(123, DataType.UNKNOWN)
+    assert type_check(None, DataType.UNKNOWN)
+    assert type_check([1, 2, 3], DataType.UNKNOWN)
+    assert type_check({"key": "value"}, DataType.UNKNOWN)
+
+    # Nullable tests
+    assert type_check(None, DataType.STRING)  # nullable by default
+    assert type_check(None, DataType.INTEGER)
+    assert type_check(None, DataType.FLOAT)
+    assert type_check(None, DataType.BOOL)
+
+    # Non-nullable tests
+    assert not type_check(None, DataType.STRING, nullable=False)
+    assert not type_check(None, DataType.INTEGER, nullable=False)
+    assert not type_check(None, DataType.FLOAT, nullable=False)
+    assert not type_check(None, DataType.BOOL, nullable=False)
+
+    # TraitDataType tests (recursive handling)
+    # Assuming TraitDataType wraps another DataType
+    trait_string_type = TraitDataType(type=DataType.STRING, traits=[])
+    assert type_check("hello", trait_string_type)
+    assert not type_check(123, trait_string_type)
+    assert type_check(None, trait_string_type)  # nullable by default
+    assert not type_check(None, trait_string_type, nullable=False)
+
+    # Nested TraitDataType
+    nested_trait_type = TraitDataType(type=DataType.STRING, traits=[])
+    assert type_check("hello", nested_trait_type)
+    assert not type_check(123, nested_trait_type)
+
+    # Edge cases and invalid types
+    # Test with unsupported/custom types should return False
+    class CustomType:
+        pass
+
+    custom_obj = CustomType()
+    # These should all return False as they don't match any known type
+    assert not type_check(custom_obj, DataType.STRING)
+    assert not type_check(custom_obj, DataType.INTEGER)
+    assert not type_check(custom_obj, DataType.ARRAY)
+
+
+def test_type_check_edge_cases():
+    """Additional edge case tests"""
+
+    # Test very large numbers
+    large_int = 2**100
+    assert type_check(large_int, DataType.INTEGER)
+    assert type_check(large_int, DataType.BIGINT)
+    assert type_check(large_int, DataType.FLOAT)  # int should match float
+
+    # Test special float values
+    assert type_check(float("inf"), DataType.FLOAT)
+    assert type_check(float("-inf"), DataType.FLOAT)
+    # Note: NaN might need special handling depending on requirements
+    # assert type_check(float('nan'), DataType.FLOAT)
+
+    # Test empty collections
+    assert type_check([], DataType.ARRAY)
+    assert type_check({}, DataType.MAP)
+    assert type_check({}, DataType.STRUCT)
+
+    # Test nested collections
+    nested_list = [[1, 2], [3, 4]]
+    nested_dict = {"outer": {"inner": "value"}}
+    assert type_check(nested_list, DataType.ARRAY)
+    assert type_check(nested_dict, DataType.MAP)
+    assert type_check(nested_dict, DataType.STRUCT)

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

{pytrilogy-0.0.3.100 → pytrilogy-0.0.3.102}/trilogy/core/exceptions.py

@@ -69,7 +69,7 @@ class DatasourceColumnBindingData:
     actual_modifiers: List[Modifier]
 
     def format_failure(self):
-        return f"Concept {self.address} value '{self.value}' with type {self.value_modifiers} does not conform to expected type {str(self.actual_type)} with modifiers {self.actual_modifiers}"
+        return f"Concept {self.address} value '{self.value}' with type {self.value_type} and {self.value_modifiers} does not conform to expected type {str(self.actual_type)} with modifiers {self.actual_modifiers}"
 
     def is_modifier_issue(self) -> bool:
         return len(self.value_modifiers) > 0 and any(

{pytrilogy-0.0.3.100 → pytrilogy-0.0.3.102}/trilogy/core/functions.py

@@ -18,6 +18,7 @@ from trilogy.core.models.author import (
     AggregateWrapper,
     Concept,
     ConceptRef,
+    Conditional,
     Function,
     Parenthetical,
     UndefinedConcept,
@@ -129,8 +130,8 @@ def validate_case_output(
 def create_struct_output(
     args: list[Any],
 ) -> StructType:
-    zipped = dict(zip(args[::2], args[1::2]))
-    types = [arg_to_datatype(x) for x in args[1::2]]
+    zipped = dict(zip(args[1::2], args[::2]))
+    types = [arg_to_datatype(x) for x in args[::2]]
     return StructType(fields=types, fields_map=zipped)
 
 
@@ -997,6 +998,8 @@ def argument_to_purpose(arg) -> Purpose:
         return argument_to_purpose(arg.content)
     elif isinstance(arg, WindowItem):
         return Purpose.PROPERTY
+    elif isinstance(arg, Conditional):
+        return Purpose.PROPERTY
     elif isinstance(arg, Concept):
         base = arg.purpose
         if (

{pytrilogy-0.0.3.100 → pytrilogy-0.0.3.102}/trilogy/core/models/author.py

@@ -259,6 +259,15 @@ class Parenthetical(
             )
         )
 
+    def with_reference_replacement(self, source, target):
+        return Parenthetical.model_construct(
+            content=(
+                self.content.with_reference_replacement(source, target)
+                if isinstance(self.content, Mergeable)
+                else self.content
+            )
+        )
+
     @property
     def concept_arguments(self) -> Sequence[ConceptRef]:
         base: List[ConceptRef] = []

{pytrilogy-0.0.3.100 → pytrilogy-0.0.3.102}/trilogy/core/models/build.py

@@ -1511,7 +1511,10 @@ def requires_concept_nesting(
 ) -> AggregateWrapper | WindowItem | FilterItem | Function | None:
     if isinstance(expr, (AggregateWrapper, WindowItem, FilterItem)):
         return expr
-    if isinstance(expr, Function) and expr.operator == FunctionType.GROUP:
+    if isinstance(expr, Function) and expr.operator in (
+        FunctionType.GROUP,
+        FunctionType.PARENTHETICAL,
+    ):
         # group by requires nesting
         return expr
     return None
@@ -1696,13 +1699,12 @@ class Factory:
         return self._build_case_when(base)
 
     def _build_case_when(self, base: CaseWhen) -> BuildCaseWhen:
-        comparison = base.comparison
         expr: Concept | FuncArgs = base.expr
         validation = requires_concept_nesting(expr)
         if validation:
             expr, _ = self.instantiate_concept(validation)
         return BuildCaseWhen(
-            comparison=self.build(comparison),
+            comparison=self.build(base.comparison),
             expr=self.build(expr),
         )
 
@@ -2019,7 +2021,12 @@ class Factory:
         return self._build_parenthetical(base)
 
     def _build_parenthetical(self, base: Parenthetical) -> BuildParenthetical:
-        return BuildParenthetical(content=(self.build(base.content)))
+        validate = requires_concept_nesting(base.content)
+        if validate:
+            content, _ = self.instantiate_concept(validate)
+            return BuildParenthetical(content=self.build(content))
+        else:
+            return BuildParenthetical(content=self.build(base.content))
 
     @build.register
     def _(self, base: SelectLineage) -> BuildSelectLineage:

{pytrilogy-0.0.3.100 → pytrilogy-0.0.3.102}/trilogy/core/models/core.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from abc import ABC
 from collections import UserDict, UserList
 from datetime import date, datetime
+from decimal import Decimal
 from enum import Enum
 from typing import (
     Any,
@@ -448,6 +449,8 @@ def arg_to_datatype(arg) -> CONCRETE_TYPES:
         return DataType.STRING
     elif isinstance(arg, float):
         return DataType.FLOAT
+    elif isinstance(arg, Decimal):
+        return DataType.NUMERIC
     elif isinstance(arg, DataType):
         return arg
     elif isinstance(arg, NumericType):

{pytrilogy-0.0.3.100 → pytrilogy-0.0.3.102}/trilogy/core/processing/node_generators/group_node.py

@@ -28,6 +28,7 @@ def get_aggregate_grain(
     parent_concepts: List[BuildConcept] = unique(
         resolve_function_parent_concepts(concept, environment=environment), "address"
     )
+
     if (
         concept.grain
         and len(concept.grain.components) > 0

{pytrilogy-0.0.3.100 → pytrilogy-0.0.3.102}/trilogy/core/processing/node_generators/node_merge_node.py

@@ -164,9 +164,6 @@ def reinject_common_join_keys_v2(
             reduced = BuildGrain.from_concepts(concrete_concepts).components
             existing_addresses = set()
             for concrete in concrete_concepts:
-                logger.debug(
-                    f"looking at column {concrete.address} with pseudonyms {concrete.pseudonyms}"
-                )
                 cnode = concept_to_node(concrete.with_default_grain())
                 if cnode in final.nodes:
                     existing_addresses.add(concrete.address)

{pytrilogy-0.0.3.100 → pytrilogy-0.0.3.102}/trilogy/core/validation/datasource.py

@@ -36,31 +36,51 @@ def type_check(
 ) -> bool:
     if input is None and nullable:
         return True
+
     target_type = expected_type
     while isinstance(target_type, TraitDataType):
         return type_check(input, target_type.data_type, nullable)
+
     if target_type == DataType.STRING:
         return isinstance(input, str)
     if target_type == DataType.INTEGER:
         return isinstance(input, int)
+    if target_type == DataType.BIGINT:
+        return isinstance(input, int)  # or check for larger int if needed
     if target_type == DataType.FLOAT or isinstance(target_type, NumericType):
         return (
             isinstance(input, float)
             or isinstance(input, int)
             or isinstance(input, Decimal)
         )
+    if target_type == DataType.NUMBER:
+        return isinstance(input, (int, float, Decimal))
+    if target_type == DataType.NUMERIC:
+        return isinstance(input, (int, float, Decimal))
     if target_type == DataType.BOOL:
         return isinstance(input, bool)
     if target_type == DataType.DATE:
-        return isinstance(input, date)
+        return isinstance(input, date) and not isinstance(input, datetime)
     if target_type == DataType.DATETIME:
         return isinstance(input, datetime)
+    if target_type == DataType.TIMESTAMP:
+        return isinstance(input, datetime)  # or timestamp type if you have one
+    if target_type == DataType.UNIX_SECONDS:
+        return isinstance(input, (int, float))  # Unix timestamps are numeric
+    if target_type == DataType.DATE_PART:
+        return isinstance(
+            input, str
+        )  # assuming date parts are strings like "year", "month"
     if target_type == DataType.ARRAY or isinstance(target_type, ArrayType):
         return isinstance(input, list)
     if target_type == DataType.MAP or isinstance(target_type, MapType):
         return isinstance(input, dict)
     if target_type == DataType.STRUCT or isinstance(target_type, StructType):
         return isinstance(input, dict)
+    if target_type == DataType.NULL:
+        return input is None
+    if target_type == DataType.UNKNOWN:
+        return True
     return False
 
 
@@ -125,15 +145,19 @@ def validate_datasource(
             rval = row[actual_address]
             passed = type_check(rval, col.concept.datatype, col.is_nullable)
             if not passed:
+                value_type = (
+                    arg_to_datatype(rval) if rval is not None else col.concept.datatype
+                )
+                traits = None
+                if isinstance(col.concept.datatype, TraitDataType):
+                    traits = col.concept.datatype.traits
+                if traits and not isinstance(value_type, TraitDataType):
+                    value_type = TraitDataType(type=value_type, traits=traits)
                 failures.append(
                     DatasourceColumnBindingData(
                         address=col.concept.address,
                         value=rval,
-                        value_type=(
-                            arg_to_datatype(rval)
-                            if rval is not None
-                            else col.concept.datatype
-                        ),
+                        value_type=value_type,
                         value_modifiers=[Modifier.NULLABLE] if rval is None else [],
                         actual_type=col.concept.datatype,
                         actual_modifiers=col.concept.modifiers,

{pytrilogy-0.0.3.100 → pytrilogy-0.0.3.102}/trilogy/dialect/base.py

@@ -163,7 +163,7 @@ def render_case(args):
 
 
 def struct_arg(args):
-    return [f"{x[0]}: {x[1]}" for x in zip(args[::2], args[1::2])]
+    return [f"{x[1]}: {x[0]}" for x in zip(args[::2], args[1::2])]
 
 
 FUNCTION_MAP = {

{pytrilogy-0.0.3.100 → pytrilogy-0.0.3.102}/trilogy/parsing/common.py

@@ -249,11 +249,14 @@ def atom_is_relevant(
         return atom_is_relevant(atom.left, others, environment) or atom_is_relevant(
             atom.right, others, environment
         )
+    elif isinstance(atom, Parenthetical):
+        return atom_is_relevant(atom.content, others, environment)
     elif isinstance(atom, ConceptArgs):
         # use atom is relevant here to trigger the early exit behavior for concepts in set
         return any(
             [atom_is_relevant(x, others, environment) for x in atom.concept_arguments]
         )
+
     return False
 
 
@@ -294,12 +297,18 @@ def concept_is_relevant(
         if all([c in others for c in concept.grain.components]):
             return False
     if concept.derivation in (Derivation.BASIC,) and isinstance(
-        concept.lineage, Function
+        concept.lineage, (Function, CaseWhen)
     ):
         relevant = False
         for arg in concept.lineage.arguments:
             relevant = atom_is_relevant(arg, others, environment) or relevant
+
         return relevant
+    if concept.derivation in (Derivation.BASIC,) and isinstance(
+        concept.lineage, Parenthetical
+    ):
+        return atom_is_relevant(concept.lineage.content, others, environment)
+
     if concept.granularity == Granularity.SINGLE_ROW:
         return False
     return True
@@ -346,6 +355,7 @@ def concepts_to_grain_concepts(
         if sub.address in seen:
             continue
         if not concept_is_relevant(sub, pconcepts, environment):  # type: ignore
+
             continue
         seen.add(sub.address)
 

{pytrilogy-0.0.3.100 → pytrilogy-0.0.3.102}/trilogy/parsing/parse_engine.py

@@ -992,6 +992,9 @@ class ParseToObjects(Transformer):
     def order_by(self, args):
         return OrderBy(items=args[0])
 
+    def over_component(self, args):
+        return ConceptRef(address=args[0].value.lstrip(",").strip())
+
     def over_list(self, args):
         return [x for x in args]