pytrilogy 0.0.3.9__tar.gz → 0.0.3.11__tar.gz

{pytrilogy-0.0.3.9/pytrilogy.egg-info → pytrilogy-0.0.3.11}/PKG-INFO

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

{pytrilogy-0.0.3.9 → pytrilogy-0.0.3.11/pytrilogy.egg-info}/PKG-INFO

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

{pytrilogy-0.0.3.9 → pytrilogy-0.0.3.11}/pytrilogy.egg-info/SOURCES.txt

@@ -24,9 +24,11 @@ tests/test_parse_engine.py
 tests/test_parsing.py
 tests/test_partial_handling.py
 tests/test_query_processing.py
+tests/test_query_render.py
 tests/test_select.py
 tests/test_show.py
 tests/test_statements.py
+tests/test_typing.py
 tests/test_undefined_concept.py
 tests/test_user_functions.py
 tests/test_where_clause.py
@@ -37,6 +39,7 @@ trilogy/engine.py
 trilogy/executor.py
 trilogy/parser.py
 trilogy/py.typed
+trilogy/render.py
 trilogy/utility.py
 trilogy/authoring/__init__.py
 trilogy/core/__init__.py

{pytrilogy-0.0.3.9 → pytrilogy-0.0.3.11}/tests/test_parsing.py

@@ -8,7 +8,11 @@ from trilogy.core.models.core import (
     TupleWrapper,
 )
 from trilogy.core.models.datasource import Datasource
-from trilogy.core.models.environment import Environment
+from trilogy.core.models.environment import (
+    DictImportResolver,
+    Environment,
+    EnvironmentOptions,
+)
 from trilogy.core.statements.author import SelectStatement, ShowStatement
 from trilogy.core.statements.execute import ProcessedQuery
 from trilogy.dialect.base import BaseDialect
@@ -619,3 +623,41 @@ select [1,2,3,4] as int_array, 2 as scalar
 
     env, parsed = parse_text(x)
     assert env.concepts["split"].datatype == DataType.INTEGER
+
+
+def test_non_file_imports():
+
+    env = Environment(
+        config=EnvironmentOptions(
+            import_resolver=DictImportResolver(
+                content={
+                    "test": """
+import test_dep as test_dep;
+key x int;
+
+datasource test (
+x: x)
+grain(x)
+query '''
+select 1 as x
+union all
+select 11 as x
+''';
+""",
+                    "test_dep": """
+key x int;
+""",
+                }
+            )
+        )
+    )
+    assert isinstance(env.config.import_resolver, DictImportResolver)
+    env.parse(
+        """
+    import test;
+               
+select x % 10 -> x_mod_10;
+               
+            
+"""
+    )

pytrilogy-0.0.3.11/tests/test_query_render.py

@@ -0,0 +1,13 @@
+from trilogy import Dialects, Environment
+from trilogy.core.query_processor import process_query
+from trilogy.render import get_dialect_generator
+
+
+def test_sql_generators():
+    env = Environment()
+    _, statements = env.parse("""const a <- 1; select a;""")
+    processed = process_query(env, statements[-1])
+    for dialect in Dialects:
+        generator = get_dialect_generator(dialect)
+        compiled = generator.compile_statement(processed)
+        assert compiled.startswith("""SELECT\n    :a"""), f'{dialect} compiled'

pytrilogy-0.0.3.11/tests/test_typing.py

@@ -0,0 +1,42 @@
+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"]

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

{pytrilogy-0.0.3.9 → pytrilogy-0.0.3.11}/trilogy/authoring/__init__.py

@@ -33,11 +33,20 @@ from trilogy.core.models.author import (
     WindowOrder,
     WindowType,
 )
-from trilogy.core.models.core import DataType, ListType, ListWrapper, StructType
+from trilogy.core.models.core import (
+    DataType,
+    ListType,
+    ListWrapper,
+    MapType,
+    StructType,
+)
 from trilogy.core.models.environment import Environment
 from trilogy.core.statements.author import (
     ConceptDeclarationStatement,
     ConceptTransform,
+    MultiSelectStatement,
+    PersistStatement,
+    RawSQLStatement,
     SelectItem,
     SelectStatement,
 )
@@ -60,6 +69,7 @@ __all__ = [
     "DataType",
     "StructType",
     "ListType",
+    "MapType",
     "ListWrapper",
     "FunctionType",
     "FunctionFactory",
@@ -87,4 +97,7 @@ __all__ = [
     "DEFAULT_NAMESPACE",
     "arbitrary_to_concept",
     "arg_to_datatype",
+    "MultiSelectStatement",
+    "PersistStatement",
+    "RawSQLStatement",
 ]

{pytrilogy-0.0.3.9 → pytrilogy-0.0.3.11}/trilogy/core/enums.py

@@ -172,6 +172,7 @@ class FunctionType(Enum):
     UPPER = "upper"
     SUBSTRING = "substring"
     STRPOS = "strpos"
+    CONTAINS = "contains"
 
     # Dates
     DATE = "date"

{pytrilogy-0.0.3.9 → pytrilogy-0.0.3.11}/trilogy/core/functions.py

@@ -271,6 +271,15 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
         output_type=DataType.INTEGER,
         arg_count=2,
     ),
+    FunctionType.CONTAINS: FunctionConfig(
+        valid_inputs=[
+            {DataType.STRING},
+            {DataType.STRING},
+        ],
+        output_purpose=Purpose.PROPERTY,
+        output_type=DataType.BOOL,
+        arg_count=2,
+    ),
     FunctionType.SUBSTRING: FunctionConfig(
         valid_inputs=[{DataType.STRING}, {DataType.INTEGER}, {DataType.INTEGER}],
         output_purpose=Purpose.PROPERTY,

{pytrilogy-0.0.3.9 → pytrilogy-0.0.3.11}/trilogy/core/models/author.py

@@ -55,6 +55,7 @@ from trilogy.core.models.core import (
     MapWrapper,
     NumericType,
     StructType,
+    TraitDataType,
     TupleWrapper,
     arg_to_datatype,
     is_compatible_datatype,
@@ -101,9 +102,9 @@ class HasUUID(ABC):
 
 class ConceptRef(Addressable, Namespaced, DataTyped, Mergeable, BaseModel):
     address: str
-    datatype: DataType | ListType | StructType | MapType | NumericType = (
-        DataType.UNKNOWN
-    )
+    datatype: (
+        DataType | TraitDataType | ListType | StructType | MapType | NumericType
+    ) = DataType.UNKNOWN
     metadata: Optional["Metadata"] = None
 
     @property
@@ -756,7 +757,7 @@ class Concept(Addressable, DataTyped, ConceptArgs, Mergeable, Namespaced, BaseMo
         extra="forbid",
     )
     name: str
-    datatype: DataType | ListType | StructType | MapType | NumericType
+    datatype: DataType | TraitDataType | ListType | StructType | MapType | NumericType
     purpose: Purpose
     derivation: Derivation = Derivation.ROOT
     granularity: Granularity = Granularity.MULTI_ROW
@@ -1217,9 +1218,9 @@ class UndefinedConceptFull(Concept, Mergeable, Namespaced):
     model_config = ConfigDict(arbitrary_types_allowed=True)
     name: str
     line_no: int | None = None
-    datatype: DataType | ListType | StructType | MapType | NumericType = (
-        DataType.UNKNOWN
-    )
+    datatype: (
+        DataType | TraitDataType | ListType | StructType | MapType | NumericType
+    ) = DataType.UNKNOWN
     purpose: Purpose = Purpose.UNKNOWN
 
     @property
@@ -2153,6 +2154,11 @@ class ArgBinding(BaseModel):
     default: Expr | None = None
 
 
+class CustomType(BaseModel):
+    name: str
+    type: DataType
+
+
 Expr = (
     MagicConstants
     | bool

{pytrilogy-0.0.3.9 → pytrilogy-0.0.3.11}/trilogy/core/models/core.py

@@ -97,6 +97,19 @@ class DataType(Enum):
         return self
 
 
+class TraitDataType(BaseModel):
+    type: DataType
+    traits: list[str]
+
+    @property
+    def data_type(self):
+        return self.type
+
+    @property
+    def value(self):
+        return self.data_type.value
+
+
 class NumericType(BaseModel):
     precision: int = 20
     scale: int = 5

{pytrilogy-0.0.3.9 → pytrilogy-0.0.3.11}/trilogy/core/models/environment.py

@@ -40,6 +40,7 @@ from trilogy.core.exceptions import (
 from trilogy.core.models.author import (
     Concept,
     ConceptRef,
+    CustomType,
     Function,
     SelectLineage,
     UndefinedConcept,
@@ -59,8 +60,23 @@ class Import:
     path: Path
 
 
+class BaseImportResolver(BaseModel):
+    pass
+
+
+class FileSystemImportResolver(BaseImportResolver):
+    pass
+
+
+class DictImportResolver(BaseImportResolver):
+    content: Dict[str, str]
+
+
 class EnvironmentOptions(BaseModel):
     allow_duplicate_declaration: bool = True
+    import_resolver: BaseImportResolver = Field(
+        default_factory=FileSystemImportResolver
+    )
 
 
 class EnvironmentConceptDict(dict):
@@ -191,14 +207,14 @@ class Environment(BaseModel):
         EnvironmentDatasourceDict, PlainValidator(validate_datasources)
     ] = Field(default_factory=EnvironmentDatasourceDict)
     functions: Dict[str, Callable[..., Any]] = Field(default_factory=dict)
-    data_types: Dict[str, DataType] = Field(default_factory=dict)
+    data_types: Dict[str, CustomType] = Field(default_factory=dict)
     named_statements: Dict[str, SelectLineage] = Field(default_factory=dict)
     imports: Dict[str, list[Import]] = Field(
         default_factory=lambda: defaultdict(list)  # type: ignore
     )
     namespace: str = DEFAULT_NAMESPACE
     working_path: str | Path = Field(default_factory=lambda: os.getcwd())
-    environment_config: EnvironmentOptions = Field(default_factory=EnvironmentOptions)
+    config: EnvironmentOptions = Field(default_factory=EnvironmentOptions)
     version: str = Field(default_factory=get_version)
     cte_name_map: Dict[str, str] = Field(default_factory=dict)
     materialized_concepts: set[str] = Field(default_factory=set)
@@ -233,7 +249,7 @@ class Environment(BaseModel):
             imports=dict(self.imports),
             namespace=self.namespace,
             working_path=self.working_path,
-            environment_config=self.environment_config,
+            environment_config=self.config,
             version=self.version,
             cte_name_map=dict(self.cte_name_map),
             materialized_concepts=set(self.materialized_concepts),
@@ -341,7 +357,7 @@ class Environment(BaseModel):
 
             return None
 
-        if existing and self.environment_config.allow_duplicate_declaration:
+        if existing and self.config.allow_duplicate_declaration:
             if existing.metadata.concept_source == ConceptSource.PERSIST_STATEMENT:
                 return handle_persist()
             return

{pytrilogy-0.0.3.9 → pytrilogy-0.0.3.11}/trilogy/core/processing/nodes/group_node.py

@@ -92,7 +92,7 @@ class GroupNode(StrategyNode):
             comp_grain += source.grain
             for x in source.output_concepts:
                 concept_map[x.address] = x
-        lookups = [
+        lookups: list[BuildConcept | str] = [
             concept_map[x] if x in concept_map else x for x in comp_grain.components
         ]
         comp_grain = BuildGrain.from_concepts(lookups, environment=environment)

{pytrilogy-0.0.3.9 → pytrilogy-0.0.3.11}/trilogy/core/statements/author.py

@@ -15,8 +15,11 @@ from trilogy.core.enums import (
 from trilogy.core.models.author import (
     AggregateWrapper,
     AlignClause,
+    ArgBinding,
     Concept,
     ConceptRef,
+    CustomType,
+    Expr,
     FilterItem,
     Function,
     Grain,
@@ -413,3 +416,13 @@ class ConceptDeclarationStatement(HasUUID, BaseModel):
 
 class ConceptDerivationStatement(BaseModel):
     concept: Concept
+
+
+class TypeDeclaration(BaseModel):
+    type: CustomType
+
+
+class FunctionDeclaration(BaseModel):
+    name: str
+    args: list[ArgBinding]
+    expr: Expr

{pytrilogy-0.0.3.9 → pytrilogy-0.0.3.11}/trilogy/dialect/base.py

@@ -184,6 +184,7 @@ FUNCTION_MAP = {
     FunctionType.LOWER: lambda x: f"LOWER({x[0]}) ",
     FunctionType.SUBSTRING: lambda x: f"SUBSTRING({x[0]},{x[1]},{x[2]})",
     FunctionType.STRPOS: lambda x: f"STRPOS({x[0]},{x[1]})",
+    FunctionType.CONTAINS: lambda x: f"CONTAINS({x[0]},{x[1]})",
     # FunctionType.NOT_LIKE: lambda x: f" CASE WHEN {x[0]} like {x[1]} THEN 0 ELSE 1 END",
     # date types
     FunctionType.DATE_TRUNCATE: lambda x: f"date_trunc({x[0]},{x[1]})",

{pytrilogy-0.0.3.9 → pytrilogy-0.0.3.11}/trilogy/dialect/bigquery.py

@@ -42,10 +42,9 @@ CREATE OR REPLACE TABLE {{ output.address.location }} AS
 {% endif %}{%- if ctes %}
 WITH {% for cte in ctes %}
 {{cte.name}} as ({{cte.statement}}){% if not loop.last %},{% endif %}{% endfor %}{% endif %}
-{%- if full_select %}
+{%- if full_select -%}
 {{full_select}}
-{% else -%}
-
+{%- else -%}
 SELECT
 {%- for select in select_columns %}
     {{ select }}{% if not loop.last %},{% endif %}{% endfor %}

{pytrilogy-0.0.3.9 → pytrilogy-0.0.3.11}/trilogy/dialect/duckdb.py

@@ -57,8 +57,8 @@ CREATE OR REPLACE TABLE {{ output.address.location }} AS
 WITH {% for cte in ctes %}
 {{cte.name}} as ({{cte.statement}}){% if not loop.last %},{% endif %}{% endfor %}{% endif %}
 {%- if full_select -%}{{full_select}}
-{%- else -%}{%- if comment %}
--- {{ comment }}{% endif %}
+{%- else -%}{%- if comment -%}
+-- {{ comment }}{%- endif -%}
 SELECT
 {%- for select in select_columns %}
     {{ select }}{% if not loop.last %},{% endif %}{% endfor %}

{pytrilogy-0.0.3.9 → pytrilogy-0.0.3.11}/trilogy/dialect/enums.py

@@ -41,6 +41,11 @@ class Dialects(Enum):
             return cls.DUCK_DB
         return super()._missing_(value)
 
+    def default_renderer(self, conf=None, _engine_factory: Callable = default_factory):
+        from trilogy.render import get_dialect_generator
+
+        return get_dialect_generator(self)
+
     def default_engine(self, conf=None, _engine_factory: Callable = default_factory):
         if self == Dialects.BIGQUERY:
             from google.auth import default

{pytrilogy-0.0.3.9 → pytrilogy-0.0.3.11}/trilogy/dialect/presto.py

@@ -50,7 +50,7 @@ WITH {% for cte in ctes %}
 {{cte.name}} as ({{cte.statement}}){% if not loop.last %},{% endif %}{% endfor %}{% endif %}
 {%- if full_select -%}
 {{full_select}}
-{%- else %}
+{%- else -%}
 SELECT
 {%- for select in select_columns %}
     {{ select }}{% if not loop.last %},{% endif %}{% endfor %}

{pytrilogy-0.0.3.9 → pytrilogy-0.0.3.11}/trilogy/dialect/sql_server.py

@@ -42,7 +42,7 @@ WITH {% for cte in ctes %}
 {{cte.name}} as ({{cte.statement}}){% if not loop.last %},{% endif %}{% endfor %}{% endif %}
 {%- if full_select -%}{{full_select}}
 {%- else -%}{%- if comment %}
--- {{ comment }}{% endif %}
+-- {{ comment }}{%- endif -%}
 SELECT
 {%- if limit is not none %}
 TOP {{ limit }}{% endif %}

{pytrilogy-0.0.3.9 → pytrilogy-0.0.3.11}/trilogy/executor.py

@@ -36,6 +36,7 @@ from trilogy.dialect.enums import Dialects
 from trilogy.engine import ExecutionEngine
 from trilogy.hooks.base_hook import BaseHook
 from trilogy.parser import parse_text
+from trilogy.render import get_dialect_generator
 
 
 class ResultProtocol(Protocol):
@@ -82,40 +83,7 @@ class Executor(object):
         self.generator: BaseDialect
         self.logger = logger
         self.hooks = hooks
-        if self.dialect == Dialects.BIGQUERY:
-            from trilogy.dialect.bigquery import BigqueryDialect
-
-            self.generator = BigqueryDialect()
-        elif self.dialect == Dialects.SQL_SERVER:
-            from trilogy.dialect.sql_server import SqlServerDialect
-
-            self.generator = SqlServerDialect()
-        elif self.dialect == Dialects.DUCK_DB:
-            from trilogy.dialect.duckdb import DuckDBDialect
-
-            self.generator = DuckDBDialect()
-        elif self.dialect == Dialects.PRESTO:
-            from trilogy.dialect.presto import PrestoDialect
-
-            self.generator = PrestoDialect()
-        elif self.dialect == Dialects.TRINO:
-            from trilogy.dialect.presto import TrinoDialect
-
-            self.generator = TrinoDialect()
-        elif self.dialect == Dialects.POSTGRES:
-            from trilogy.dialect.postgres import PostgresDialect
-
-            self.generator = PostgresDialect()
-        elif self.dialect == Dialects.SNOWFLAKE:
-            from trilogy.dialect.snowflake import SnowflakeDialect
-
-            self.generator = SnowflakeDialect()
-        elif self.dialect == Dialects.DATAFRAME:
-            from trilogy.dialect.dataframe import DataframeDialect
-
-            self.generator = DataframeDialect()
-        else:
-            raise ValueError(f"Unsupported dialect {self.dialect}")
+        self.generator = get_dialect_generator(self.dialect)
         self.connection = self.engine.connect()
         # TODO: make generic
         if self.dialect == Dialects.DATAFRAME: