pytrilogy 0.0.2.33__tar.gz → 0.0.2.34__tar.gz

{pytrilogy-0.0.2.33/pytrilogy.egg-info → pytrilogy-0.0.2.34}/PKG-INFO

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

{pytrilogy-0.0.2.33 → pytrilogy-0.0.2.34/pytrilogy.egg-info}/PKG-INFO

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

{pytrilogy-0.0.2.33 → pytrilogy-0.0.2.34}/pytrilogy.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ tests/test_imports.py
 tests/test_metadata.py
 tests/test_models.py
 tests/test_multi_join_assignments.py
+tests/test_parse_engine.py
 tests/test_parsing.py
 tests/test_partial_handling.py
 tests/test_query_processing.py

{pytrilogy-0.0.2.33 → pytrilogy-0.0.2.34}/tests/test_environment.py

@@ -1,6 +1,7 @@
 from trilogy.core.models import Environment
 from pathlib import Path
 from trilogy.core.enums import Modifier
+from trilogy.core.exceptions import UndefinedConceptException
 
 
 def test_environment_serialization(test_environment: Environment):
@@ -23,6 +24,21 @@ def test_environment_from_path():
     assert "local.id" in env.concepts
 
 
+def test_environment_invalid():
+
+    env = Environment()
+    env.concepts.fail_on_missing = False
+    x = env.concepts["abc"]
+    assert x.name == "abc"
+
+    env.concepts.fail_on_missing = True
+    try:
+        x = env.concepts["abc"]
+        assert 1 == 0
+    except Exception as e:
+        assert isinstance(e, UndefinedConceptException)
+
+
 def test_environment_merge():
     env1: Environment
     env1, _ = Environment().parse(

pytrilogy-0.0.2.34/tests/test_parse_engine.py

@@ -0,0 +1,30 @@
+from trilogy.parsing.parse_engine import ParseToObjects, PARSER, unpack_visit_error
+from trilogy import Environment
+from trilogy.core.exceptions import UndefinedConceptException
+from pytest import raises
+
+TEXT = """
+const a <- 1;
+
+select
+    a,
+    b
+;
+"""
+
+
+def test_parser():
+    env = Environment()
+    x = ParseToObjects(environment=env)
+    x.environment.concepts.fail_on_missing = False
+    x.set_text(TEXT)
+    tokens = PARSER.parse(TEXT)
+    x.transform(tokens)
+    failed = False
+    try:
+        x.hydrate_missing()
+    except Exception as e:
+        failed = True
+        with raises(UndefinedConceptException):
+            unpack_visit_error(e)
+    assert failed

{pytrilogy-0.0.2.33 → pytrilogy-0.0.2.34}/tests/test_undefined_concept.py

@@ -32,6 +32,6 @@ def test_undefined_concept_dict():
     try:
         env["orid"]
     except UndefinedConceptException as e:
-        assert e.suggestions == ["local.order_id"]
+        assert e.suggestions == ["order_id"]
         assert "suggestions" in e.message.lower()
         assert "order_id" in e.message.lower()

{pytrilogy-0.0.2.33 → pytrilogy-0.0.2.34}/trilogy/__init__.py

@@ -4,6 +4,6 @@ from trilogy.executor import Executor
 from trilogy.parser import parse
 from trilogy.constants import CONFIG
 
-__version__ = "0.0.2.33"
+__version__ = "0.0.2.34"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

{pytrilogy-0.0.2.33 → pytrilogy-0.0.2.34}/trilogy/core/models.py

@@ -3218,7 +3218,7 @@ class EnvironmentConceptDict(dict):
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(self, *args, **kwargs)
         self.undefined: dict[str, UndefinedConcept] = {}
-        self.fail_on_missing: bool = False
+        self.fail_on_missing: bool = True
         self.populate_default_concepts()
 
     def populate_default_concepts(self):
@@ -3460,8 +3460,8 @@ class Environment(BaseModel):
 
         if not exists:
             self.imports[alias].append(imp_stm)
-        else:
-            return self
+        # we can't exit early
+        # as there may be new concepts
         for k, concept in source.concepts.items():
             if same_namespace:
                 new = self.add_concept(concept, _ignore_cache=True)
@@ -3525,8 +3525,11 @@ class Environment(BaseModel):
             try:
                 with open(target, "r", encoding="utf-8") as f:
                     text = f.read()
+                nenv = Environment(
+                    working_path=target.parent,
+                )
+                nenv.concepts.fail_on_missing = False
                 nparser = ParseToObjects(
-                    visit_tokens=True,
                     environment=Environment(
                         working_path=target.parent,
                     ),
@@ -3535,6 +3538,7 @@ class Environment(BaseModel):
                 )
                 nparser.set_text(text)
                 nparser.transform(PARSER.parse(text))
+
             except Exception as e:
                 raise ImportError(
                     f"Unable to import file {target.parent}, parsing error: {e}"

{pytrilogy-0.0.2.33 → pytrilogy-0.0.2.34}/trilogy/parsing/parse_engine.py

@@ -227,7 +227,6 @@ def unwrap_transformation(
 class ParseToObjects(Transformer):
     def __init__(
         self,
-        visit_tokens,
         environment: Environment,
         parse_address: str | None = None,
         token_address: Path | None = None,
@@ -235,7 +234,7 @@ class ParseToObjects(Transformer):
         tokens: dict[Path | str, ParseTree] | None = None,
         text_lookup: dict[Path | str, str] | None = None,
     ):
-        Transformer.__init__(self, visit_tokens)
+        Transformer.__init__(self, True)
         self.environment: Environment = environment
         self.parse_address: str = parse_address or SELF_LABEL
         self.token_address: Path | str = token_address or SELF_LABEL
@@ -254,16 +253,20 @@ class ParseToObjects(Transformer):
         self.tokens[self.token_address] = tree
         return results
 
+    def prepare_parse(self):
+        self.pass_count = 1
+        self.environment.concepts.fail_on_missing = False
+        for _, v in self.parsed.items():
+            v.prepare_parse()
+
     def hydrate_missing(self):
         self.pass_count = 2
         for k, v in self.parsed.items():
-
             if v.pass_count == 2:
                 continue
+            print(f"Hydrating {k}")
             v.hydrate_missing()
-        # self.environment.concepts.fail_on_missing = True
-        # if not self.environment.concepts.undefined:
-        #     return self._results_stash
+        self.environment.concepts.fail_on_missing = True
         reparsed = self.transform(self.tokens[self.token_address])
         self.environment.concepts.undefined = {}
         return reparsed
@@ -850,12 +853,12 @@ class ParseToObjects(Transformer):
             nparser = self.parsed[cache_lookup]
         else:
             try:
+                new_env = Environment(
+                    working_path=dirname(target),
+                )
+                new_env.concepts.fail_on_missing = False
                 nparser = ParseToObjects(
-                    visit_tokens=True,
-                    environment=Environment(
-                        working_path=dirname(target),
-                        # namespace=alias,
-                    ),
+                    environment=new_env,
                     parse_address=cache_lookup,
                     token_address=token_lookup,
                     parsed={**self.parsed, **{self.parse_address: self}},
@@ -1954,12 +1957,14 @@ def parse_text(text: str, environment: Optional[Environment] = None) -> Tuple[
     ],
 ]:
     environment = environment or Environment()
-    parser = ParseToObjects(visit_tokens=True, environment=environment)
+    parser = ParseToObjects(environment=environment)
 
     try:
         parser.set_text(text)
+        # disable fail on missing to allow for circular dependencies
+        parser.prepare_parse()
         parser.transform(PARSER.parse(text))
-        # handle circular dependencies
+        # this will reset fail on missing
         pass_two = parser.hydrate_missing()
         output = [v for v in pass_two if v]
     except VisitError as e: