pytrilogy 0.0.3.3__tar.gz → 0.0.3.5__tar.gz

{pytrilogy-0.0.3.3/pytrilogy.egg-info → pytrilogy-0.0.3.5}/PKG-INFO

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

{pytrilogy-0.0.3.3 → pytrilogy-0.0.3.5/pytrilogy.egg-info}/PKG-INFO

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

{pytrilogy-0.0.3.3 → pytrilogy-0.0.3.5}/pytrilogy.egg-info/SOURCES.txt

@@ -37,6 +37,7 @@ trilogy/executor.py
 trilogy/parser.py
 trilogy/py.typed
 trilogy/utility.py
+trilogy/authoring/__init__.py
 trilogy/core/__init__.py
 trilogy/core/constants.py
 trilogy/core/enums.py

{pytrilogy-0.0.3.3 → pytrilogy-0.0.3.5}/tests/test_datatypes.py

@@ -9,7 +9,7 @@ from trilogy.parsing.parse_engine import (
 
 def test_numeric():
     env, _ = parse_text(
-        "const order_id numeric(12,2); const rounded <- cast(order_id as numeric(15,2));"
+        "const order_id numeric(12,2); auto rounded <- cast(order_id as numeric(15,2));"
     )
     assert env.concepts["order_id"].datatype == NumericType(precision=12, scale=2)
 

{pytrilogy-0.0.3.3 → pytrilogy-0.0.3.5}/tests/test_executor.py

@@ -5,8 +5,11 @@ from trilogy.core.models.environment import Environment
 
 
 def test_file_parsing():
-    target = Path(__file__).parent / "test_env.preql"
-    parsed = Dialects.DUCK_DB.default_executor().parse_file(target)
+    directory = Path(__file__).parent
+    target = directory / "test_env.preql"
+    parsed = Dialects.DUCK_DB.default_executor(
+        environment=Environment(working_path=directory)
+    ).parse_file(target)
     assert len(list(parsed)) == 1
 
 

{pytrilogy-0.0.3.3 → pytrilogy-0.0.3.5}/tests/test_imports.py

@@ -1,6 +1,6 @@
 from pathlib import Path
 
-from trilogy.core.models.environment import Environment
+from trilogy.core.models.environment import Environment, LazyEnvironment
 
 
 def test_multi_environment():
@@ -41,3 +41,14 @@ key id2 int;
     assert basic.concepts["id"].name == "id"
     assert basic.concepts["id2"].name == "id2"
     assert basic.concepts["id"].namespace == basic.concepts["id2"].namespace
+
+
+def test_import_concept_resolution():
+    basic = LazyEnvironment(
+        load_path=Path(__file__).parent / "test_lazy_env.preql",
+        working_path=Path(__file__).parent,
+        setup_queries=[],
+    )
+    materialized = basic.materialize_for_select()
+    assert "one.two.import_key" in materialized.materialized_concepts
+    assert "two.two.import_key" in materialized.materialized_concepts

{pytrilogy-0.0.3.3 → pytrilogy-0.0.3.5}/tests/test_parsing.py

@@ -323,7 +323,7 @@ def test_circular_aliasing():
 property composite_id.first <- split(composite_id, '-')[1];
 property composite_id.second <- split(composite_id, '-')[2];
 
-key composite_id_alt <- concat(first, '-', second);
+auto composite_id_alt <- concat(first, '-', second);
 
 merge composite_id_alt into composite_id;
 
@@ -367,7 +367,7 @@ def test_circular_aliasing_inverse():
 property composite_id.first <- split(composite_id, '-')[1];
 property composite_id.second <- split(composite_id, '-')[2];
 
-key composite_id_alt <- concat(first, '-', second);
+auto composite_id_alt <- concat(first, '-', second);
 
 merge composite_id_alt into composite_id;
 

{pytrilogy-0.0.3.3 → pytrilogy-0.0.3.5}/tests/test_where_clause.py

@@ -89,7 +89,7 @@ select
 
 def test_select_where_attribute_v2(test_environment):
     declarations = """
-key special_category <- filter category_id where like(category_name, '%special%') is True;
+auto special_category <- filter category_id where like(category_name, '%special%') is True;
 
 select
     order_id,

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

pytrilogy-0.0.3.5/trilogy/authoring/__init__.py

@@ -0,0 +1,90 @@
+from trilogy.constants import DEFAULT_NAMESPACE
+from trilogy.core.enums import (
+    BooleanOperator,
+    ComparisonOperator,
+    FunctionClass,
+    FunctionType,
+    InfiniteFunctionArgs,
+    Ordering,
+    Purpose,
+)
+from trilogy.core.functions import FunctionFactory
+from trilogy.core.models.author import (
+    AggregateWrapper,
+    CaseElse,
+    CaseWhen,
+    Comparison,
+    Concept,
+    ConceptRef,
+    Conditional,
+    FilterItem,
+    Function,
+    HavingClause,
+    MagicConstants,
+    Metadata,
+    OrderBy,
+    OrderItem,
+    Parenthetical,
+    SubselectComparison,
+    WhereClause,
+    WindowItem,
+    WindowItemOrder,
+    WindowItemOver,
+    WindowOrder,
+    WindowType,
+)
+from trilogy.core.models.core import DataType, ListType, ListWrapper, StructType
+from trilogy.core.models.environment import Environment
+from trilogy.core.statements.author import (
+    ConceptDeclarationStatement,
+    ConceptTransform,
+    SelectItem,
+    SelectStatement,
+)
+from trilogy.parsing.common import arbitrary_to_concept, arg_to_datatype
+
+__all__ = [
+    "Concept",
+    "Function",
+    "WhereClause",
+    "Comparison",
+    "FilterItem",
+    "CaseWhen",
+    "CaseElse",
+    "AggregateWrapper",
+    "WindowItem",
+    "WindowOrder",
+    "WindowType",
+    "WindowItemOrder",
+    "WindowItemOver",
+    "DataType",
+    "StructType",
+    "ListType",
+    "ListWrapper",
+    "FunctionType",
+    "FunctionFactory",
+    "ConceptDeclarationStatement",
+    "ConceptTransform",
+    "SelectItem",
+    "SelectStatement",
+    "Environment",
+    "ConceptRef",
+    "HavingClause",
+    "MagicConstants",
+    "Metadata",
+    "OrderBy",
+    "OrderItem",
+    "Parenthetical",
+    "SubselectComparison",
+    "Conditional",
+    "BooleanOperator",
+    "ComparisonOperator",
+    "FunctionClass",
+    "FunctionType",
+    "InfiniteFunctionArgs",
+    "Ordering",
+    "Purpose",
+    "DEFAULT_NAMESPACE",
+    "arbitrary_to_concept",
+    "arg_to_datatype",
+]

{pytrilogy-0.0.3.3 → pytrilogy-0.0.3.5}/trilogy/core/models/author.py

@@ -166,10 +166,8 @@ class UndefinedConcept(ConceptRef):
 
 
 def address_with_namespace(address: str, namespace: str) -> str:
-    ns = address.split(".", 1)[0]
-    if ns == namespace:
-        return address
-    if ns == DEFAULT_NAMESPACE:
+    existing_ns = address.split(".", 1)[0]
+    if existing_ns == DEFAULT_NAMESPACE:
         return f"{namespace}.{address.split('.',1)[1]}"
     return f"{namespace}.{address}"
 
@@ -203,7 +201,7 @@ class Parenthetical(
     def __repr__(self):
         return f"({str(self.content)})"
 
-    def with_namespace(self, namespace: str):
+    def with_namespace(self, namespace: str) -> Parenthetical:
         return Parenthetical.model_construct(
             content=(
                 self.content.with_namespace(namespace)
@@ -917,8 +915,6 @@ class Concept(Addressable, DataTyped, ConceptArgs, Mergeable, Namespaced, BaseMo
         return self.name.replace(".", "_")
 
     def with_namespace(self, namespace: str) -> Self:
-        if namespace == self.namespace:
-            return self
         return self.__class__.model_construct(
             name=self.name,
             datatype=self.datatype,

{pytrilogy-0.0.3.3 → pytrilogy-0.0.3.5}/trilogy/core/models/environment.py

@@ -8,6 +8,7 @@ from pathlib import Path
 from typing import (
     TYPE_CHECKING,
     Annotated,
+    Any,
     Dict,
     ItemsView,
     List,
@@ -383,14 +384,13 @@ class Environment(BaseModel):
             ):
                 exists = True
             imp_stm = Import(alias=alias, path=Path(source.working_path))
-        same_namespace = alias == self.namespace
+        same_namespace = alias == DEFAULT_NAMESPACE
 
         if not exists:
             self.imports[alias].append(imp_stm)
         # we can't exit early
         # as there may be new concepts
         for k, concept in source.concepts.items():
-
             # skip internal namespace
             if INTERNAL_NAMESPACE in concept.address:
                 continue
@@ -416,7 +416,6 @@ class Environment(BaseModel):
                 self.alias_origin_lookup[address_with_namespace(key, alias)] = (
                     val.with_namespace(alias)
                 )
-
         return self
 
     def add_file_import(
@@ -457,8 +456,10 @@ class Environment(BaseModel):
                     token_address=target,
                 )
                 nparser.set_text(text)
+                nparser.environment.concepts.fail_on_missing = False
                 nparser.transform(PARSER.parse(text))
                 nparser.hydrate_missing()
+                nparser.environment.concepts.fail_on_missing = True
 
             except Exception as e:
                 raise ImportError(
@@ -664,37 +665,59 @@ class LazyEnvironment(Environment):
     until relevant attributes accessed."""
 
     load_path: Path
+    setup_queries: list[Any] = Field(default_factory=list)
     loaded: bool = False
 
+    @property
+    def setup_path(self) -> Path:
+        return self.load_path.parent / "setup.preql"
+
     def __init__(self, **data):
+        if not data.get("working_path"):
+            data["working_path"] = data["load_path"].parent
         super().__init__(**data)
+        assert self.working_path == self.load_path.parent
 
     def _add_path_concepts(self):
         pass
 
+    def _load(self):
+        if self.loaded:
+            return
+        from trilogy import parse
+
+        env = Environment(working_path=self.load_path.parent)
+        assert env.working_path == self.load_path.parent
+        with open(self.load_path, "r") as f:
+            env, _ = parse(f.read(), env)
+        if self.setup_path.exists():
+            with open(self.setup_path, "r") as f2:
+                env, q = parse(f2.read(), env)
+                for q in q:
+                    self.setup_queries.append(q)
+        self.loaded = True
+        self.datasources = env.datasources
+        self.concepts = env.concepts
+        self.imports = env.imports
+        self.alias_origin_lookup = env.alias_origin_lookup
+        self.materialized_concepts = env.materialized_concepts
+        self.functions = env.functions
+        self.data_types = env.data_types
+        self.cte_name_map = env.cte_name_map
+
     def __getattribute__(self, name):
-        if name in (
-            "load_path",
-            "loaded",
-            "working_path",
-            "model_config",
-            "model_fields",
-            "model_post_init",
+        if name not in (
+            "datasources",
+            "concepts",
+            "imports",
+            "materialized_concepts",
+            "functions",
+            "datatypes",
+            "cte_name_map",
         ) or name.startswith("_"):
             return super().__getattribute__(name)
         if not self.loaded:
-            logger.info(
-                f"lazily evaluating load path {self.load_path} to access {name}"
-            )
-            from trilogy import parse
-
-            env = Environment(working_path=str(self.working_path))
-            with open(self.load_path, "r") as f:
-                parse(f.read(), env)
-            self.loaded = True
-            self.datasources = env.datasources
-            self.concepts = env.concepts
-            self.imports = env.imports
+            self._load()
         return super().__getattribute__(name)
 
 

{pytrilogy-0.0.3.3 → pytrilogy-0.0.3.5}/trilogy/core/processing/concept_strategies_v3.py

@@ -1046,7 +1046,7 @@ def source_query_concepts(
             f"{c.address}<{c.purpose}>{c.derivation}>" for c in output_concepts
         ]
         raise ValueError(
-            f"Could not resolve conections between {error_strings} from environment graph."
+            f"Could not resolve connections between {error_strings} from environment graph."
         )
     final = [x for x in root.output_concepts if x.address not in root.hidden_concepts]
     logger.info(

{pytrilogy-0.0.3.3 → pytrilogy-0.0.3.5}/trilogy/core/query_processor.py

@@ -385,7 +385,7 @@ def get_query_node(
     )
     graph = generate_graph(build_environment)
     logger.info(
-        f"{LOGGER_PREFIX} getting source datasource for outputs {statement.output_components} grain {build_statement.grain}"
+        f"{LOGGER_PREFIX} getting source datasource for outputs {build_statement.output_components} grain {build_statement.grain}"
     )
 
     search_concepts: list[BuildConcept] = build_statement.output_components

{pytrilogy-0.0.3.3 → pytrilogy-0.0.3.5}/trilogy/executor.py

@@ -346,10 +346,10 @@ class Executor(object):
         file = Path(file)
         with open(file, "r") as f:
             command = f.read()
-            return self.parse_text_generator(command, persist=persist)
+            return self.parse_text_generator(command, persist=persist, root=file)
 
     def parse_text(
-        self, command: str, persist: bool = False
+        self, command: str, persist: bool = False, root: Path | None = None
     ) -> List[
         ProcessedQuery
         | ProcessedQueryPersist
@@ -357,9 +357,11 @@ class Executor(object):
         | ProcessedRawSQLStatement
         | ProcessedCopyStatement
     ]:
-        return list(self.parse_text_generator(command, persist=persist))
+        return list(self.parse_text_generator(command, persist=persist, root=root))
 
-    def parse_text_generator(self, command: str, persist: bool = False) -> Generator[
+    def parse_text_generator(
+        self, command: str, persist: bool = False, root: Path | None = None
+    ) -> Generator[
         ProcessedQuery
         | ProcessedQueryPersist
         | ProcessedShowStatement
@@ -369,7 +371,7 @@ class Executor(object):
         None,
     ]:
         """Process a preql text command"""
-        _, parsed = parse_text(command, self.environment)
+        _, parsed = parse_text(command, self.environment, root=root)
         generatable = [
             x
             for x in parsed

{pytrilogy-0.0.3.3 → pytrilogy-0.0.3.5}/trilogy/parsing/common.py

@@ -152,7 +152,6 @@ def constant_to_concept(
     parent: ListWrapper | MapWrapper | list | int | float | str,
     name: str,
     namespace: str,
-    purpose: Purpose | None = None,
     metadata: Metadata | None = None,
 ) -> Concept:
     const_function: Function = Function(
@@ -340,7 +339,6 @@ def filter_item_to_concept(
     name: str,
     namespace: str,
     environment: Environment,
-    purpose: Purpose | None = None,
     metadata: Metadata | None = None,
 ) -> Concept:
     fmetadata = metadata or Metadata()
@@ -377,14 +375,13 @@ def window_item_to_concept(
     name: str,
     namespace: str,
     environment: Environment,
-    purpose: Purpose | None = None,
     metadata: Metadata | None = None,
 ) -> Concept:
     fmetadata = metadata or Metadata()
     bcontent = environment.concepts[parent.content.address]
     if isinstance(bcontent, UndefinedConcept):
         return UndefinedConcept(address=f"{namespace}.{name}", metadata=fmetadata)
-    local_purpose, keys = get_purpose_and_keys(purpose, (bcontent,), environment)
+    local_purpose, keys = get_purpose_and_keys(None, (bcontent,), environment)
 
     if parent.order_by:
         grain_components = parent.over + [bcontent.output]
@@ -568,7 +565,6 @@ def arbitrary_to_concept(
     namespace: str | None = None,
     name: str | None = None,
     metadata: Metadata | None = None,
-    purpose: Purpose | None = None,
 ) -> Concept:
     namespace = namespace or environment.namespace
     if isinstance(parent, AggregateWrapper):
@@ -585,7 +581,6 @@ def arbitrary_to_concept(
             name,
             namespace,
             environment=environment,
-            purpose=purpose,
             metadata=metadata,
         )
     elif isinstance(parent, FilterItem):
@@ -596,7 +591,6 @@ def arbitrary_to_concept(
             name,
             namespace,
             environment=environment,
-            purpose=purpose,
             metadata=metadata,
         )
     elif isinstance(parent, Function):
@@ -612,8 +606,8 @@ def arbitrary_to_concept(
     elif isinstance(parent, ListWrapper):
         if not name:
             name = f"{VIRTUAL_CONCEPT_PREFIX}_{string_to_hash(str(parent))}"
-        return constant_to_concept(parent, name, namespace, purpose, metadata)
+        return constant_to_concept(parent, name, namespace, metadata)
     else:
         if not name:
             name = f"{VIRTUAL_CONCEPT_PREFIX}_{string_to_hash(str(parent))}"
-        return constant_to_concept(parent, name, namespace, purpose, metadata)
+        return constant_to_concept(parent, name, namespace, metadata)

{pytrilogy-0.0.3.3 → pytrilogy-0.0.3.5}/trilogy/parsing/parse_engine.py

@@ -147,6 +147,9 @@ with open(join(dirname(__file__), "trilogy.lark"), "r") as f:
 
 
 def gen_cache_lookup(path: str, alias: str, parent: str) -> str:
+    # path is the path of the file
+    # alias is what it's being imported under
+    # parent is the...direct parnet?
     return path + alias + parent
 
 
@@ -252,10 +255,12 @@ class ParseToObjects(Transformer):
         for _, v in self.parsed.items():
             v.prepare_parse()
 
-    def hydrate_missing(self):
+    def hydrate_missing(self, force: bool = False):
+        if self.token_address not in self.tokens:
+            return []
         self.parse_pass = ParsePass.VALIDATION
-        for k, v in self.parsed.items():
-            if v.parse_pass == ParsePass.VALIDATION:
+        for _, v in list(self.parsed.items()):
+            if v.parse_pass == ParsePass.VALIDATION and not force:
                 continue
             v.hydrate_missing()
         reparsed = self.transform(self.tokens[self.token_address])
@@ -390,7 +395,6 @@ class ParseToObjects(Transformer):
 
     @v_args(meta=True)
     def column_assignment(self, meta: Meta, args):
-        # TODO -> deal with conceptual modifiers
         modifiers = []
         alias = args[0]
         concept_list = args[1]
@@ -398,6 +402,7 @@ class ParseToObjects(Transformer):
         if len(concept_list) > 1:
             modifiers += concept_list[:-1]
         concept = concept_list[-1]
+        assert not self.environment.concepts.fail_on_missing
         resolved = self.environment.concepts.__getitem__(  # type: ignore
             key=concept, line_no=meta.line, file=self.token_address
         )
@@ -508,8 +513,6 @@ class ParseToObjects(Transformer):
         else:
             metadata = None
         purpose = args[0]
-        if purpose == Purpose.AUTO:
-            purpose = None
         raw_name = args[1]
         # abc.def.property pattern
         if isinstance(raw_name, str):
@@ -538,10 +541,14 @@ class ParseToObjects(Transformer):
                 name=name,
                 namespace=namespace,
                 environment=self.environment,
-                purpose=purpose,
                 metadata=metadata,
             )
 
+            if purpose and purpose != Purpose.AUTO and concept.purpose != purpose:
+                raise SyntaxError(
+                    f'Concept {name} purpose {concept.purpose} does not match declared purpose {purpose}. Suggest defaulting to "auto"'
+                )
+
             if concept.metadata:
                 concept.metadata.line_number = meta.line
             self.environment.add_concept(concept, meta=meta)
@@ -552,7 +559,6 @@ class ParseToObjects(Transformer):
                 source_value,
                 name=name,
                 namespace=namespace,
-                purpose=purpose,
                 metadata=metadata,
             )
             if concept.metadata:
@@ -577,15 +583,6 @@ class ParseToObjects(Transformer):
             namespace=self.environment.namespace or DEFAULT_NAMESPACE,
         )
 
-        # clean up current definitions
-        # to_delete = set()
-        # if output.name in self.environment.named_statements:
-        #     for k, v in self.environment.concepts.items():
-        #         if v.derivation == Derivation.ROWSET and v.lineage.rowset.name == name:
-        #             to_delete.add(k)
-        # for k in to_delete:
-        #     self.environment.concepts.pop(k)
-
         for new_concept in rowset_to_concepts(output, self.environment):
             if new_concept.metadata:
                 new_concept.metadata.line_number = meta.line
@@ -887,10 +884,14 @@ class ParseToObjects(Transformer):
         if cache_lookup in self.parsed:
             nparser = self.parsed[cache_lookup]
             new_env = nparser.environment
+            if nparser.parse_pass != ParsePass.VALIDATION:
+                # nparser.transform(raw_tokens)
+                nparser.hydrate_missing()
         else:
             try:
                 new_env = Environment(
                     working_path=dirname(target),
+                    env_file_path=token_lookup,
                 )
                 new_env.concepts.fail_on_missing = False
                 self.parsed[self.parse_address] = self
@@ -908,10 +909,11 @@ class ParseToObjects(Transformer):
                 raise ImportError(
                     f"Unable to import file {target}, parsing error: {e}"
                 ) from e
+        parsed_path = Path(args[0])
+        imps = ImportStatement(alias=alias, path=parsed_path)
 
-        imps = ImportStatement(alias=alias, path=Path(args[0]))
         self.environment.add_import(
-            alias, new_env, Import(alias=alias, path=Path(args[0]))
+            alias, new_env, Import(alias=alias, path=parsed_path)
         )
         return imps
 
@@ -1602,7 +1604,9 @@ def parse_text_raw(text: str, environment: Optional[Environment] = None):
     PARSER.parse(text)
 
 
-def parse_text(text: str, environment: Optional[Environment] = None) -> Tuple[
+def parse_text(
+    text: str, environment: Optional[Environment] = None, root: Path | None = None
+) -> Tuple[
     Environment,
     List[
         Datasource
@@ -1614,7 +1618,9 @@ def parse_text(text: str, environment: Optional[Environment] = None) -> Tuple[
         | None
     ],
 ]:
-    environment = environment or Environment()
+    environment = environment or (
+        Environment(working_path=root) if root else Environment()
+    )
     parser = ParseToObjects(environment=environment)
 
     try:
@@ -1623,7 +1629,7 @@ def parse_text(text: str, environment: Optional[Environment] = None) -> Tuple[
         parser.prepare_parse()
         parser.transform(PARSER.parse(text))
         # this will reset fail on missing
-        pass_two = parser.hydrate_missing()
+        pass_two = parser.hydrate_missing(force=True)
         output = [v for v in pass_two if v]
         environment.concepts.fail_on_missing = True
     except VisitError as e: