pytrilogy 0.0.3.24__tar.gz → 0.0.3.26__tar.gz

{pytrilogy-0.0.3.24/pytrilogy.egg-info → pytrilogy-0.0.3.26}/PKG-INFO

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

{pytrilogy-0.0.3.24 → pytrilogy-0.0.3.26/pytrilogy.egg-info}/PKG-INFO

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

{pytrilogy-0.0.3.24 → pytrilogy-0.0.3.26}/setup.py

@@ -40,7 +40,7 @@ setuptools.setup(
         ]
     ),
     package_data={
-        "": ["*.tf", "*.jinja", "py.typed", "*.lark"],
+        "": ["*.tf", "*.jinja", "py.typed", "*.lark", "*.preql"],
     },
     install_requires=install_requires,
     extras_require={

{pytrilogy-0.0.3.24 → pytrilogy-0.0.3.26}/tests/test_functions.py

@@ -122,8 +122,21 @@ def test_date_functions(test_environment):
         quarter(order_timestamp) -> order_quarter,
         year(order_timestamp) -> order_year,
         date_trunc(order_timestamp, month) -> order_month_trunc,
-        date_part(order_timestamp, month) -> order_month_part,
         date_add(order_timestamp, month, 1) -> one_month_post_order,
+        date_trunc(order_timestamp, day) -> order_day_trunc,
+        date_trunc(order_timestamp, year) -> order_year_trunc,
+        date_trunc(order_timestamp, hour) -> order_hour_trunc,
+        date_trunc(order_timestamp, minute) -> order_minute_trunc,
+        date_trunc(order_timestamp, second) -> order_second_trunc,
+        date_part(order_timestamp, month) -> order_month_part,
+        date_part(order_timestamp, day) -> order_day_part,
+        date_part(order_timestamp, year) -> order_year_part,
+        date_part(order_timestamp, hour) -> order_hour_part,
+        date_part(order_timestamp, minute) -> order_minute_part,
+        date_part(order_timestamp, second) -> order_second_part,
+        date_part(order_timestamp, quarter) -> order_quarter_part,
+        date_part(order_timestamp, week) -> order_week_part,
+        date_part(order_timestamp, day_of_week) -> order_day_of_week_part,
     ;
     
     

{pytrilogy-0.0.3.24 → pytrilogy-0.0.3.26}/tests/test_parsing.py

@@ -657,7 +657,10 @@ key x int;
     assert isinstance(env.config.import_resolver, DictImportResolver)
     env.parse(
         """
-    import test;
+import std.geography;
+import test;
+
+key fun_lat float::latitude;
                
 select x % 10 -> x_mod_10;
                

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

{pytrilogy-0.0.3.24 → pytrilogy-0.0.3.26}/trilogy/core/enums.py

@@ -298,6 +298,7 @@ class DatePart(Enum):
     HOUR = "hour"
     MINUTE = "minute"
     SECOND = "second"
+    DAY_OF_WEEK = "day_of_week"
 
     @classmethod
     def _missing_(cls, value):

{pytrilogy-0.0.3.24 → pytrilogy-0.0.3.26}/trilogy/core/environment_helpers.py

@@ -1,6 +1,6 @@
 from trilogy.constants import DEFAULT_NAMESPACE
 from trilogy.core.enums import ConceptSource, FunctionType, Purpose
-from trilogy.core.functions import AttrAccess
+from trilogy.core.functions import AttrAccess, FunctionFactory
 from trilogy.core.models.author import Concept, Function, Metadata
 from trilogy.core.models.core import DataType, StructType, arg_to_datatype
 from trilogy.core.models.environment import Environment
@@ -19,6 +19,7 @@ FUNCTION_DESCRIPTION_MAPS = {
 
 
 def generate_date_concepts(concept: Concept, environment: Environment):
+    factory = FunctionFactory(environment=environment)
     if concept.metadata and concept.metadata.description:
         base_description = concept.metadata.description
     else:
@@ -40,17 +41,15 @@ def generate_date_concepts(concept: Concept, environment: Environment):
             if concept.purpose == Purpose.CONSTANT
             else Purpose.PROPERTY
         )
-        const_function: Function = Function(
+        function = factory.create_function(
             operator=ftype,
-            output_datatype=DataType.INTEGER,
-            output_purpose=default_type,
-            arguments=[concept],
+            args=[concept],
         )
         new_concept = Concept(
             name=f"{concept.name}.{fname}",
             datatype=DataType.INTEGER,
             purpose=default_type,
-            lineage=const_function,
+            lineage=function,
             grain=concept.grain,
             namespace=concept.namespace,
             keys=set(
@@ -68,6 +67,7 @@ def generate_date_concepts(concept: Concept, environment: Environment):
 
 
 def generate_datetime_concepts(concept: Concept, environment: Environment):
+    factory = FunctionFactory(environment=environment)
     if concept.metadata and concept.metadata.description:
         base_description = concept.metadata.description
     else:
@@ -88,11 +88,10 @@ def generate_datetime_concepts(concept: Concept, environment: Environment):
             if concept.purpose == Purpose.CONSTANT
             else Purpose.PROPERTY
         )
-        const_function: Function = Function(
+
+        const_function = factory.create_function(
             operator=ftype,
-            output_datatype=DataType.INTEGER,
-            output_purpose=default_type,
-            arguments=[concept],
+            args=[concept],
         )
         new_concept = Concept(
             name=f"{concept.name}.{fname}",

{pytrilogy-0.0.3.24 → pytrilogy-0.0.3.26}/trilogy/core/functions.py

@@ -43,7 +43,9 @@ class FunctionConfig:
     arg_count: int = 1
     valid_inputs: set[DataType] | list[set[DataType]] | None = None
     output_purpose: Purpose | None = None
-    output_type: DataType | ListType | MapType | StructType | NumericType | None = None
+    output_type: (
+        DataType | ListType | MapType | StructType | NumericType | TraitDataType | None
+    ) = None
     output_type_function: Optional[Callable] = None
 
 
@@ -124,6 +126,30 @@ def create_struct_output(
     return StructType(fields=types, fields_map=zipped)
 
 
+def get_date_part_output(args: list[Any]):
+    target = args[1]
+    if target == DatePart.YEAR:
+        return TraitDataType(type=DataType.INTEGER, traits=["year"])
+    elif target == DatePart.MONTH:
+        return TraitDataType(type=DataType.INTEGER, traits=["month"])
+    elif target == DatePart.DAY:
+        return TraitDataType(type=DataType.INTEGER, traits=["day"])
+    elif target == DatePart.HOUR:
+        return TraitDataType(type=DataType.INTEGER, traits=["hour"])
+    elif target == DatePart.MINUTE:
+        return TraitDataType(type=DataType.INTEGER, traits=["minute"])
+    elif target == DatePart.SECOND:
+        return TraitDataType(type=DataType.INTEGER, traits=["second"])
+    elif target == DatePart.WEEK:
+        return TraitDataType(type=DataType.INTEGER, traits=["week"])
+    elif target == DatePart.QUARTER:
+        return TraitDataType(type=DataType.INTEGER, traits=["quarter"])
+    elif target == DatePart.DAY_OF_WEEK:
+        return TraitDataType(type=DataType.INTEGER, traits=["day_of_week"])
+    else:
+        raise InvalidSyntaxException(f"Date part not supported for {target}")
+
+
 def get_date_trunc_output(
     args: list[Any],
 ):
@@ -360,7 +386,7 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
             {DataType.DATE_PART},
         ],
         output_purpose=Purpose.PROPERTY,
-        output_type=DataType.INTEGER,
+        output_type_function=get_date_part_output,
         arg_count=2,
     ),
     FunctionType.DATE_ADD: FunctionConfig(
@@ -443,7 +469,7 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
             DataType.STRING,
         },
         output_purpose=Purpose.PROPERTY,
-        output_type=DataType.INTEGER,
+        output_type=TraitDataType(type=DataType.INTEGER, traits=["second"]),
         arg_count=1,
     ),
     FunctionType.MINUTE: FunctionConfig(
@@ -454,7 +480,7 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
             DataType.STRING,
         },
         output_purpose=Purpose.PROPERTY,
-        output_type=DataType.INTEGER,
+        output_type=TraitDataType(type=DataType.INTEGER, traits=["minute"]),
         arg_count=1,
     ),
     FunctionType.HOUR: FunctionConfig(
@@ -465,7 +491,7 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
             DataType.STRING,
         },
         output_purpose=Purpose.PROPERTY,
-        output_type=DataType.INTEGER,
+        output_type=TraitDataType(type=DataType.INTEGER, traits=["hour"]),
         arg_count=1,
     ),
     FunctionType.DAY: FunctionConfig(
@@ -476,7 +502,7 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
             DataType.STRING,
         },
         output_purpose=Purpose.PROPERTY,
-        output_type=DataType.INTEGER,
+        output_type=TraitDataType(type=DataType.INTEGER, traits=["day"]),
         arg_count=1,
     ),
     FunctionType.WEEK: FunctionConfig(
@@ -487,7 +513,7 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
             DataType.STRING,
         },
         output_purpose=Purpose.PROPERTY,
-        output_type=DataType.INTEGER,
+        output_type=TraitDataType(type=DataType.INTEGER, traits=["week"]),
         arg_count=1,
     ),
     FunctionType.MONTH: FunctionConfig(
@@ -498,7 +524,7 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
             DataType.STRING,
         },
         output_purpose=Purpose.PROPERTY,
-        output_type=DataType.INTEGER,
+        output_type=TraitDataType(type=DataType.INTEGER, traits=["month"]),
         arg_count=1,
     ),
     FunctionType.QUARTER: FunctionConfig(
@@ -509,7 +535,7 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
             DataType.STRING,
         },
         output_purpose=Purpose.PROPERTY,
-        output_type=DataType.INTEGER,
+        output_type=TraitDataType(type=DataType.INTEGER, traits=["quarter"]),
         arg_count=1,
     ),
     FunctionType.YEAR: FunctionConfig(
@@ -520,7 +546,7 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
             DataType.STRING,
         },
         output_purpose=Purpose.PROPERTY,
-        output_type=DataType.INTEGER,
+        output_type=TraitDataType(type=DataType.INTEGER, traits=["year"]),
         arg_count=1,
     ),
     FunctionType.DAY_OF_WEEK: FunctionConfig(
@@ -531,7 +557,7 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
             DataType.STRING,
         },
         output_purpose=Purpose.PROPERTY,
-        output_type=DataType.INTEGER,
+        output_type=TraitDataType(type=DataType.INTEGER, traits=["day_of_week"]),
         arg_count=1,
     ),
     FunctionType.ADD: FunctionConfig(

{pytrilogy-0.0.3.24 → pytrilogy-0.0.3.26}/trilogy/core/models/author.py

@@ -255,7 +255,7 @@ class Parenthetical(
         return arg_to_datatype(self.content)
 
 
-class Conditional(Mergeable, ConceptArgs, Namespaced, BaseModel):
+class Conditional(Mergeable, ConceptArgs, Namespaced, DataTyped, BaseModel):
     left: Expr
     right: Expr
     operator: BooleanOperator
@@ -357,6 +357,11 @@ class Conditional(Mergeable, ConceptArgs, Namespaced, BaseModel):
             output += self.right.existence_arguments
         return output
 
+    @property
+    def output_datatype(self):
+        # a conditional is always a boolean
+        return DataType.BOOL
+
     def decompose(self):
         chunks = []
         if self.operator == BooleanOperator.AND:
@@ -545,7 +550,7 @@ class Grain(Namespaced, BaseModel):
             return self.__add__(other)
 
 
-class Comparison(ConceptArgs, Mergeable, Namespaced, BaseModel):
+class Comparison(ConceptArgs, Mergeable, DataTyped, Namespaced, BaseModel):
     left: Union[
         int,
         str,
@@ -745,6 +750,11 @@ class Comparison(ConceptArgs, Mergeable, Namespaced, BaseModel):
             output += self.right.existence_arguments
         return output
 
+    @property
+    def output_datatype(self):
+        # a conditional is always a boolean
+        return DataType.BOOL
+
 
 class SubselectComparison(Comparison):
     def __eq__(self, other):
@@ -1401,7 +1411,7 @@ def get_basic_type(
     if isinstance(type, NumericType):
         return DataType.NUMERIC
     if isinstance(type, TraitDataType):
-        return type.type
+        return get_basic_type(type.type)
     return type
 
 

{pytrilogy-0.0.3.24 → pytrilogy-0.0.3.26}/trilogy/core/models/core.py

@@ -105,7 +105,7 @@ class DataType(Enum):
 
 
 class TraitDataType(BaseModel):
-    type: DataType
+    type: DataType | NumericType | StructType | ListType | MapType
     traits: list[str]
 
     def __hash__(self):
@@ -134,6 +134,9 @@ class NumericType(BaseModel):
     precision: int = 20
     scale: int = 5
 
+    def __str__(self) -> str:
+        return f"Numeric({self.precision},{self.scale})"
+
     @property
     def data_type(self):
         return DataType.NUMERIC
@@ -356,12 +359,21 @@ def merge_datatypes(
 
 def is_compatible_datatype(left, right):
     # for unknown types, we can't make any assumptions
+    if all(
+        isinstance(x, NumericType)
+        or x in (DataType.INTEGER, DataType.FLOAT, DataType.NUMERIC)
+        for x in (left, right)
+    ):
+        return True
+    elif isinstance(left, NumericType) or isinstance(right, NumericType):
+        return False
     if right == DataType.UNKNOWN or left == DataType.UNKNOWN:
         return True
     if left == right:
         return True
     if {left, right} == {DataType.NUMERIC, DataType.FLOAT}:
         return True
+
     if {left, right} == {DataType.NUMERIC, DataType.INTEGER}:
         return True
     if {left, right} == {DataType.FLOAT, DataType.INTEGER}:

{pytrilogy-0.0.3.24 → pytrilogy-0.0.3.26}/trilogy/dialect/base.py

@@ -680,7 +680,7 @@ class BaseDialect:
         elif isinstance(e, datetime):
             return self.FUNCTION_MAP[FunctionType.DATETIME_LITERAL](e)
         elif isinstance(e, TraitDataType):
-            return self.DATATYPE_MAP.get(e.type, e.type.value)
+            return self.render_expr(e.type, cte=cte, cte_map=cte_map)
         else:
             raise ValueError(f"Unable to render type {type(e)} {e}")
 

{pytrilogy-0.0.3.24 → pytrilogy-0.0.3.26}/trilogy/parsing/parse_engine.py

@@ -91,6 +91,7 @@ from trilogy.core.models.core import (
     TupleWrapper,
     arg_to_datatype,
     dict_to_map_wrapper,
+    is_compatible_datatype,
     list_to_wrapper,
     tuple_to_wrapper,
 )
@@ -146,6 +147,8 @@ SELF_LABEL = "root"
 
 MAX_PARSE_DEPTH = 10
 
+STDLIB_ROOT = Path(__file__).parent.parent
+
 
 @dataclass
 class WholeGrainWrapper:
@@ -449,20 +452,27 @@ class ParseToObjects(Transformer):
     ) -> DataType | TraitDataType | ListType | StructType | MapType | NumericType:
         resolved = args[0]
         traits = args[2:]
+        base: DataType | TraitDataType | ListType | StructType | MapType | NumericType
         if isinstance(resolved, StructType):
-            return resolved
+            base = resolved
         elif isinstance(resolved, ListType):
-            return resolved
+            base = resolved
         elif isinstance(resolved, NumericType):
-            return resolved
+            base = resolved
         elif isinstance(resolved, MapType):
-            return resolved
-        base = DataType(args[0].lower())
+            base = resolved
+        else:
+            base = DataType(args[0].lower())
         if traits:
             for trait in traits:
                 if trait not in self.environment.data_types:
                     raise ParseError(
-                        f"Invalid type trait {trait} for {base}, line {meta.line}"
+                        f"Invalid trait (type) {trait} for {base}, line {meta.line}."
+                    )
+                matched = self.environment.data_types[trait]
+                if not is_compatible_datatype(matched.type, base):
+                    raise ParseError(
+                        f"Invalid trait (type) {trait} for {base}, line {meta.line}. Trait expects type {matched.type}, has {base}"
                     )
             return TraitDataType(type=base, traits=traits)
 
@@ -936,9 +946,12 @@ class ParseToObjects(Transformer):
             select=args[-1],
         )
 
-    def resolve_import_address(self, address) -> str:
-        if isinstance(
-            self.environment.config.import_resolver, FileSystemImportResolver
+    def resolve_import_address(self, address, is_stdlib: bool = False) -> str:
+        if (
+            isinstance(
+                self.environment.config.import_resolver, FileSystemImportResolver
+            )
+            or is_stdlib
         ):
             with open(address, "r", encoding="utf-8") as f:
                 text = f.read()
@@ -946,7 +959,7 @@ class ParseToObjects(Transformer):
             lookup = address
             if lookup not in self.environment.config.import_resolver.content:
                 raise ImportError(
-                    f"Unable to import file {lookup}, not found in import resolver"
+                    f"Unable to import file {lookup}, not found in imsport resolver"
                 )
             text = self.environment.config.import_resolver.content[lookup]
         else:
@@ -964,13 +977,17 @@ class ParseToObjects(Transformer):
             cache_key = args[0]
         input_path = args[0]
         path = input_path.split(".")
-
-        if isinstance(
+        is_stdlib = False
+        if path[0] == "std":
+            is_stdlib = True
+            target = join(STDLIB_ROOT, *path) + ".preql"
+            token_lookup: Path | str = Path(target)
+        elif isinstance(
             self.environment.config.import_resolver, FileSystemImportResolver
         ):
             target = join(self.environment.working_path, *path) + ".preql"
             # tokens + text are cached by path
-            token_lookup: Path | str = Path(target)
+            token_lookup = Path(target)
         elif isinstance(self.environment.config.import_resolver, DictImportResolver):
             target = ".".join(path)
             token_lookup = target
@@ -991,7 +1008,7 @@ class ParseToObjects(Transformer):
             raw_tokens = self.tokens[token_lookup]
             text = self.text_lookup[token_lookup]
         else:
-            text = self.resolve_import_address(target)
+            text = self.resolve_import_address(target, is_stdlib)
             self.text_lookup[token_lookup] = text
 
             try:

{pytrilogy-0.0.3.24 → pytrilogy-0.0.3.26}/trilogy/parsing/trilogy.lark

@@ -287,7 +287,7 @@
     _YEAR.1: "year("i
     fyear: _YEAR expr ")"
     
-    DATE_PART: "DAY"i | "WEEK"i | "MONTH"i | "QUARTER"i | "YEAR"i | "MINUTE"i | "HOUR"i | "SECOND"i
+    DATE_PART: "DAY"i | "WEEK"i | "MONTH"i | "QUARTER"i | "YEAR"i | "MINUTE"i | "HOUR"i | "SECOND"i | "DAY_OF_WEEK"i
     _DATE_TRUNC.1: "date_trunc("i
     fdate_trunc: _DATE_TRUNC expr "," DATE_PART ")"
     _DATE_PART.1: "date_part("i