pytrilogy 0.0.3.10__tar.gz → 0.0.3.12__tar.gz

{pytrilogy-0.0.3.10/pytrilogy.egg-info → pytrilogy-0.0.3.12}/PKG-INFO

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

{pytrilogy-0.0.3.10 → pytrilogy-0.0.3.12/pytrilogy.egg-info}/PKG-INFO

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

{pytrilogy-0.0.3.10 → pytrilogy-0.0.3.12}/pytrilogy.egg-info/SOURCES.txt

@@ -24,6 +24,7 @@ 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
@@ -38,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.10 → pytrilogy-0.0.3.12}/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.12/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.10 → pytrilogy-0.0.3.12}/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.10"
+__version__ = "0.0.3.12"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

{pytrilogy-0.0.3.10 → pytrilogy-0.0.3.12}/trilogy/authoring/__init__.py

@@ -33,7 +33,13 @@ 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,
@@ -63,6 +69,7 @@ __all__ = [
     "DataType",
     "StructType",
     "ListType",
+    "MapType",
     "ListWrapper",
     "FunctionType",
     "FunctionFactory",

{pytrilogy-0.0.3.10 → pytrilogy-0.0.3.12}/trilogy/core/models/environment.py

@@ -60,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):
@@ -199,7 +214,7 @@ class Environment(BaseModel):
     )
     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)
@@ -234,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),
@@ -342,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.10 → pytrilogy-0.0.3.12}/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.10 → pytrilogy-0.0.3.12}/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.10 → pytrilogy-0.0.3.12}/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.10 → pytrilogy-0.0.3.12}/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.10 → pytrilogy-0.0.3.12}/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.10 → pytrilogy-0.0.3.12}/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.10 → pytrilogy-0.0.3.12}/trilogy/engine.py

@@ -18,6 +18,15 @@ class EngineConnection(Protocol):
     def execute(self, statement: str, parameters: Any | None = None) -> EngineResult:
         pass
 
+    def commit(self):
+        raise NotImplementedError()
+
+    def begin(self):
+        raise NotImplementedError()
+
+    def rollback(self):
+        raise NotImplementedError()
+
 
 class ExecutionEngine(Protocol):
     pass
@@ -40,13 +49,24 @@ class SqlAlchemyResult(EngineResult):
 
 class SqlAlchemyConnection(EngineConnection):
     def __init__(self, connection: Connection):
-        self.connection = connection
+        from sqlalchemy.future import Connection
+
+        self.connection: Connection = connection
 
     def execute(
         self, statement: str, parameters: Any | None = None
     ) -> SqlAlchemyResult:
         return SqlAlchemyResult(self.connection.execute(statement, parameters))
 
+    def commit(self):
+        self.connection.commit()
+
+    def begin(self):
+        self.connection.begin()
+
+    def rollback(self):
+        self.connection.rollback()
+
 
 class SqlAlchemyEngine(ExecutionEngine):
     def __init__(self, engine: Engine):

{pytrilogy-0.0.3.10 → pytrilogy-0.0.3.12}/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:

{pytrilogy-0.0.3.10 → pytrilogy-0.0.3.12}/trilogy/parsing/parse_engine.py

@@ -97,7 +97,12 @@ from trilogy.core.models.datasource import (
     Query,
     RawColumnExpr,
 )
-from trilogy.core.models.environment import Environment, Import
+from trilogy.core.models.environment import (
+    DictImportResolver,
+    Environment,
+    FileSystemImportResolver,
+    Import,
+)
 from trilogy.core.statements.author import (
     ConceptDeclarationStatement,
     ConceptDerivationStatement,
@@ -223,7 +228,7 @@ class ParseToObjects(Transformer):
         self,
         environment: Environment,
         parse_address: str | None = None,
-        token_address: Path | None = None,
+        token_address: Path | str | None = None,
         parsed: dict[str, "ParseToObjects"] | None = None,
         tokens: dict[Path | str, ParseTree] | None = None,
         text_lookup: dict[Path | str, str] | None = None,
@@ -854,8 +859,22 @@ class ParseToObjects(Transformer):
         )
 
     def resolve_import_address(self, address) -> str:
-        with open(address, "r", encoding="utf-8") as f:
-            text = f.read()
+        if isinstance(
+            self.environment.config.import_resolver, FileSystemImportResolver
+        ):
+            with open(address, "r", encoding="utf-8") as f:
+                text = f.read()
+        elif isinstance(self.environment.config.import_resolver, DictImportResolver):
+            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"
+                )
+            text = self.environment.config.import_resolver.content[lookup]
+        else:
+            raise ImportError(
+                f"Unable to import file {address}, resolver type {type(self.environment.config.import_resolver)} not supported"
+            )
         return text
 
     def import_statement(self, args: list[str]) -> ImportStatement:
@@ -867,10 +886,17 @@ class ParseToObjects(Transformer):
             cache_key = args[0]
         path = args[0].split(".")
 
-        target = join(self.environment.working_path, *path) + ".preql"
-
-        # tokens + text are cached by path
-        token_lookup = Path(target)
+        if 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)
+        elif isinstance(self.environment.config.import_resolver, DictImportResolver):
+            target = ".".join(path)
+            token_lookup = target
+        else:
+            raise NotImplementedError
 
         # parser + env has to be cached by prior import path + current key
         key_path = self.import_keys + [cache_key]
@@ -901,6 +927,7 @@ class ParseToObjects(Transformer):
                 new_env = Environment(
                     working_path=dirname(target),
                     env_file_path=token_lookup,
+                    config=self.environment.config,
                 )
                 new_env.concepts.fail_on_missing = False
                 self.parsed[self.parse_address] = self

pytrilogy-0.0.3.12/trilogy/render.py

@@ -0,0 +1,38 @@
+from trilogy.dialect.enums import Dialects
+
+
+def get_dialect_generator(dialect: Dialects):
+    if dialect == Dialects.BIGQUERY:
+        from trilogy.dialect.bigquery import BigqueryDialect
+
+        return BigqueryDialect()
+    elif dialect == Dialects.SQL_SERVER:
+        from trilogy.dialect.sql_server import SqlServerDialect
+
+        return SqlServerDialect()
+    elif dialect == Dialects.DUCK_DB:
+        from trilogy.dialect.duckdb import DuckDBDialect
+
+        return DuckDBDialect()
+    elif dialect == Dialects.PRESTO:
+        from trilogy.dialect.presto import PrestoDialect
+
+        return PrestoDialect()
+    elif dialect == Dialects.TRINO:
+        from trilogy.dialect.presto import TrinoDialect
+
+        return TrinoDialect()
+    elif dialect == Dialects.POSTGRES:
+        from trilogy.dialect.postgres import PostgresDialect
+
+        return PostgresDialect()
+    elif dialect == Dialects.SNOWFLAKE:
+        from trilogy.dialect.snowflake import SnowflakeDialect
+
+        return SnowflakeDialect()
+    elif dialect == Dialects.DATAFRAME:
+        from trilogy.dialect.dataframe import DataframeDialect
+
+        return DataframeDialect()
+    else:
+        raise ValueError(f"Unsupported dialect {dialect}")