pytrilogy 0.0.3.100__tar.gz → 0.0.3.101__tar.gz

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

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

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

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

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

{pytrilogy-0.0.3.100 → pytrilogy-0.0.3.101}/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.101}/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.101}/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.101}/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.101}/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.101}/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.101}/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.101}/trilogy/parsing/render.py

@@ -349,7 +349,8 @@ class Renderer:
         else:
             output = f"{concept.purpose.value} {namespace}{concept.name} <- {self.to_string(concept.lineage)};"
         if base_description:
-            output += f" #{base_description}"
+            lines = "\n#".join(base_description.split("\n"))
+            output += f" #{lines}"
         return output
 
     @to_string.register
@@ -439,7 +440,7 @@ class Renderer:
 
     @to_string.register
     def _(self, arg: "Conditional"):
-        return f"({self.to_string(arg.left)} {arg.operator.value} {self.to_string(arg.right)})"
+        return f"{self.to_string(arg.left)} {arg.operator.value} {self.to_string(arg.right)}"
 
     @to_string.register
     def _(self, arg: "SubselectComparison"):
@@ -451,7 +452,8 @@ class Renderer:
 
     @to_string.register
     def _(self, arg: "Comment"):
-        return f"{arg.text}"
+        lines = "\n#".join(arg.text.split("\n"))
+        return f"{lines}"
 
     @to_string.register
     def _(self, arg: "WindowItem"):

{pytrilogy-0.0.3.100 → pytrilogy-0.0.3.101}/trilogy/parsing/trilogy.lark

@@ -134,10 +134,12 @@
     metadata: "metadata" "(" IDENTIFIER "=" string_lit ")"
     
     limit: "LIMIT"i /[0-9]+/
+
+    _order_atom: expr ordering
     
-    order_list: expr ordering (","  expr ordering)* ","?
+    order_list: _order_atom (","  _order_atom)* ","?
     
-    over_list: concept_lit (","  concept_lit )* ","?
+    over_list: (concept_lit ",")*  concept_lit ","?
     
     ORDERING_DIRECTION: /ASC|DESC/i
 
@@ -433,7 +435,8 @@
     map_lit: "{" (literal ":" literal ",")* literal ":" literal ","? "}"
 
     _STRUCT.1: "struct("i
-    struct_lit: _STRUCT (IDENTIFIER "->" expr ",")* IDENTIFIER "->" expr ","? ")"
+    _BINDING.1: "->"
+    struct_lit: _STRUCT expr _BINDING IDENTIFIER   ( "," expr _BINDING  IDENTIFIER  )* ","? ")"
     
     !bool_lit: "True"i | "False"i