pytrilogy 0.0.2.32__py3-none-any.whl → 0.0.2.34__py3-none-any.whl

{pytrilogy-0.0.2.32.dist-info → pytrilogy-0.0.2.34.dist-info}/METADATA

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

{pytrilogy-0.0.2.32.dist-info → pytrilogy-0.0.2.34.dist-info}/RECORD

@@ -1,6 +1,6 @@
-trilogy/__init__.py,sha256=CPOHf23-XKufDWmGAC9X5pKiKQAepzaB-rNzkGplJNo,291
+trilogy/__init__.py,sha256=KM64JjCIbIm0t7no7TfLDsHkXU-HC5d2by7YePMKmq8,291
 trilogy/compiler.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-trilogy/constants.py,sha256=KiyYnctoZen4Hzv8WG2jeN-IE-dfQbWHdVCUeTZYjBg,1270
+trilogy/constants.py,sha256=HQAnGUqJ5uMri7TWtqXHhz8iVWBzi2LCfRG8vKnBIB8,1269
 trilogy/engine.py,sha256=R5ubIxYyrxRExz07aZCUfrTsoXCHQ8DKFTDsobXdWdA,1102
 trilogy/executor.py,sha256=VcZ2U3RUU2al_VJ75AKVwmCJQLltYouxlgTjq4oxPB0,12577
 trilogy/parser.py,sha256=UtuqSiGiCjpMAYgo1bvNq-b7NSzCA5hzbUW31RXaMII,281
@@ -8,7 +8,7 @@ trilogy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/utility.py,sha256=zM__8r29EsyDW7K9VOHz8yvZC2bXFzh7xKy3cL7GKsk,707
 trilogy/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/core/constants.py,sha256=7XaCpZn5mQmjTobbeBn56SzPWq9eMNDfzfsRU-fP0VE,171
-trilogy/core/enums.py,sha256=y0Z0m-xtcVw1ktkQ5yD3fJYWfOa4ncN_MzCTpREAxy0,6374
+trilogy/core/enums.py,sha256=GG51K-bP3HTVuvJQFCjbmVt7iBOGpmF_qtnRVf0_obI,6396
 trilogy/core/env_processor.py,sha256=SHVB3nkidIlFc5dz-sofRMKXx66stpLQNuVdQSjC-So,2586
 trilogy/core/environment_helpers.py,sha256=DIsoo-GcXmXVPB1JbNh8Oku25Nyef9mexPIdy2ur_sk,7159
 trilogy/core/ergonomics.py,sha256=ASLDd0RqKWrZiG3XcKHo8nyTjaB_8xfE9t4NZ1UvGpc,1639
@@ -16,7 +16,7 @@ trilogy/core/exceptions.py,sha256=NvV_4qLOgKXbpotgRf7c8BANDEvHxlqRPaA53IThQ2o,56
 trilogy/core/functions.py,sha256=IhVpt3n6wEanKHnGu3oA2w6-hKIlxWpEyz7fHN66mpo,10720
 trilogy/core/graph_models.py,sha256=mameUTiuCajtihDw_2-W218xyJlvTusOWrEKP1yAWgk,2003
 trilogy/core/internal.py,sha256=jNGFHKENnbMiMCtAgsnLZYVSENDK4b5ALecXFZpTDzQ,1075
-trilogy/core/models.py,sha256=d0nmbSrR7LObYOpfx9Q5GYrXg-hV0OrBDwrIj90eGX8,159625
+trilogy/core/models.py,sha256=xZHi9IYo_vSG35rF4fp7bLrGIu8J5QXqDObpZgN0_cI,160541
 trilogy/core/optimization.py,sha256=VFSvJLNoCCOraip-PZUKeE4qrlxtXARjQUzJZiW-yRk,7325
 trilogy/core/query_processor.py,sha256=mbcZlgjChrRjDHkdmMbKe-T70UpbBkJhS09MyU5a6UY,17785
 trilogy/core/optimizations/__init__.py,sha256=bWQecbeiwiDx9LJnLsa7dkWxdbl2wcnkcTN69JyP8iI,356
@@ -27,7 +27,7 @@ trilogy/core/optimizations/predicate_pushdown.py,sha256=1l9WnFOSv79e341typG3tTdk
 trilogy/core/processing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/core/processing/concept_strategies_v3.py,sha256=Qy3WHiKaF371dDmbA0DWVQqSMKptH_gK714Uc41wbqc,36132
 trilogy/core/processing/graph_utils.py,sha256=aq-kqk4Iado2HywDxWEejWc-7PGO6Oa-ZQLAM6XWPHw,1199
-trilogy/core/processing/utility.py,sha256=VFArfoUY5EiacspwQ03uWiKRr5SzEDhIB_iMrOIPBAg,18540
+trilogy/core/processing/utility.py,sha256=_sWLDuV8WAEWdEIcAPM8-FcXgBai30UV12i4O9u5Mpc,18680
 trilogy/core/processing/node_generators/__init__.py,sha256=-mzYkRsaRNa_dfTckYkKVFSR8h8a3ihEiPJDU_tAmDo,672
 trilogy/core/processing/node_generators/basic_node.py,sha256=WQNgJ1MwrMS_BQ-b3XwGGB6eToDykelAVj_fesJuqe0,2069
 trilogy/core/processing/node_generators/common.py,sha256=eslHTTPFTkmwHwKIuUsbFn54jxj-Avtt-QScqtNwzdg,8945
@@ -66,18 +66,18 @@ trilogy/hooks/graph_hook.py,sha256=onHvMQPwj_KOS3HOTpRFiy7QLLKAiycq2MzJ_Q0Oh5Y,2
 trilogy/hooks/query_debugger.py,sha256=787umJjdGA057DCC714dqFstzJRUbwmz3MNr66IdpQI,4404
 trilogy/metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/parsing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-trilogy/parsing/common.py,sha256=t7yiL_3f6rz_rouF9et84v5orAgs-EprV4V9ghQ6ql4,10024
+trilogy/parsing/common.py,sha256=_GW9LU6_4RuUgcdcr8EE1ybCRd-7cz3idZtjHZ66pYA,10182
 trilogy/parsing/config.py,sha256=Z-DaefdKhPDmSXLgg5V4pebhSB0h590vI0_VtHnlukI,111
 trilogy/parsing/exceptions.py,sha256=92E5i2frv5hj9wxObJZsZqj5T6bglvPzvdvco_vW1Zk,38
 trilogy/parsing/helpers.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-trilogy/parsing/parse_engine.py,sha256=eCEJJ06zgWhj4DNja5CEhlwv-PrGlVMXDHUX9Q3aITM,64688
+trilogy/parsing/parse_engine.py,sha256=mMMP0TPLAHx0m4c7scXxosDIgfPYyUYmlgwAFtVeRe0,66699
 trilogy/parsing/render.py,sha256=VKyo8wEOuiOzUtJ6w9EoGGmkhlqDQyy8wFj_Q_h6EfE,15263
 trilogy/parsing/trilogy.lark,sha256=Tuqw5oGMwOYt3TYOEx_hZqGpsAp-PiAKiMW8S3EFRcg,12236
 trilogy/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/scripts/trilogy.py,sha256=PHxvv6f2ODv0esyyhWxlARgra8dVhqQhYl0lTrSyVNo,3729
-pytrilogy-0.0.2.32.dist-info/LICENSE.md,sha256=5ZRvtTyCCFwz1THxDTjAu3Lidds9WjPvvzgVwPSYNDo,1042
-pytrilogy-0.0.2.32.dist-info/METADATA,sha256=iOdK_We6Z-kEQP6SnEzowkN089iEjUCqq_Q7yGxLEkQ,8403
-pytrilogy-0.0.2.32.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-pytrilogy-0.0.2.32.dist-info/entry_points.txt,sha256=0petKryjvvtEfTlbZC1AuMFumH_WQ9v8A19LvoS6G6c,54
-pytrilogy-0.0.2.32.dist-info/top_level.txt,sha256=cAy__NW_eMAa_yT9UnUNlZLFfxcg6eimUAZ184cdNiE,8
-pytrilogy-0.0.2.32.dist-info/RECORD,,
+pytrilogy-0.0.2.34.dist-info/LICENSE.md,sha256=5ZRvtTyCCFwz1THxDTjAu3Lidds9WjPvvzgVwPSYNDo,1042
+pytrilogy-0.0.2.34.dist-info/METADATA,sha256=jvasI3x4y_xwYh4TToePk_EQIwEr0Kfw2zqESs65bQk,8403
+pytrilogy-0.0.2.34.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+pytrilogy-0.0.2.34.dist-info/entry_points.txt,sha256=0petKryjvvtEfTlbZC1AuMFumH_WQ9v8A19LvoS6G6c,54
+pytrilogy-0.0.2.34.dist-info/top_level.txt,sha256=cAy__NW_eMAa_yT9UnUNlZLFfxcg6eimUAZ184cdNiE,8
+pytrilogy-0.0.2.34.dist-info/RECORD,,

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.32"
+__version__ = "0.0.2.34"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

trilogy/constants.py

@@ -36,7 +36,7 @@ class Comments:
     basic: bool = True
     joins: bool = True
     nullable: bool = False
-    partial: bool = False
+    partial: bool = True
 
 
 # TODO: support loading from environments

trilogy/core/enums.py

@@ -13,6 +13,7 @@ class UnnestMode(Enum):
 class ConceptSource(Enum):
     MANUAL = "manual"
     CTE = "cte"
+    SELECT = "select"
     PERSIST_STATEMENT = "persist_statement"
     AUTO_DERIVED = "auto_derived"
 

trilogy/core/models.py

@@ -2077,6 +2077,11 @@ class Datasource(HasUUID, Namespaced, BaseModel):
         self, source: Concept, target: Concept, modifiers: List[Modifier]
     ):
         original = [c for c in self.columns if c.concept.address == source.address]
+        early_exit_check = [
+            c for c in self.columns if c.concept.address == target.address
+        ]
+        if early_exit_check:
+            return None
         if len(original) != 1:
             raise ValueError(
                 f"Expected exactly one column to merge, got {len(original)} for {source.address}, {[x.alias for x in original]}"
@@ -3213,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):
@@ -3332,7 +3337,6 @@ class Environment(BaseModel):
 
     materialized_concepts: List[Concept] = Field(default_factory=list)
     alias_origin_lookup: Dict[str, Concept] = Field(default_factory=dict)
-    _parse_count: int = 0
 
     @classmethod
     def from_file(cls, path: str | Path) -> "Environment":
@@ -3442,19 +3446,22 @@ class Environment(BaseModel):
         exists = False
         existing = self.imports[alias]
         if imp_stm:
-            if any([x.path == imp_stm.path for x in existing]):
+            if any(
+                [x.path == imp_stm.path and x.alias == imp_stm.alias for x in existing]
+            ):
                 exists = True
-
         else:
-            if any([x.path == source.working_path for x in existing]):
+            if any(
+                [x.path == source.working_path and x.alias == alias for x in existing]
+            ):
                 exists = True
             imp_stm = ImportStatement(alias=alias, path=Path(source.working_path))
-
         same_namespace = alias == self.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():
             if same_namespace:
                 new = self.add_concept(concept, _ignore_cache=True)
@@ -3485,13 +3492,25 @@ class Environment(BaseModel):
         self.gen_concept_list_caches()
         return self
 
-    def add_file_import(self, path: str, alias: str, env: Environment | None = None):
-        from trilogy.parsing.parse_engine import ParseToObjects, PARSER
-
-        apath = path.split(".")
-        apath[-1] = apath[-1] + ".preql"
+    def add_file_import(
+        self, path: str | Path, alias: str, env: Environment | None = None
+    ):
+        from trilogy.parsing.parse_engine import (
+            ParseToObjects,
+            PARSER,
+            gen_cache_lookup,
+        )
 
-        target: Path = Path(self.working_path, *apath)
+        if isinstance(path, str):
+            if path.endswith(".preql"):
+                path = path.rsplit(".", 1)[0]
+            if "." not in path:
+                target = Path(self.working_path, path)
+            else:
+                target = Path(self.working_path, *path.split("."))
+            target = target.with_suffix(".preql")
+        else:
+            target = path
         if alias in self.imports:
             imports = self.imports[alias]
             for x in imports:
@@ -3502,18 +3521,24 @@ class Environment(BaseModel):
                 ImportStatement(alias=alias, path=target, environment=env)
             )
         else:
+            parse_address = gen_cache_lookup(str(target), alias, str(self.working_path))
             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,
-                    text=text,
                     environment=Environment(
                         working_path=target.parent,
                     ),
-                    parse_address=str(target),
+                    parse_address=parse_address,
+                    token_address=target,
                 )
+                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}"

trilogy/core/processing/utility.py

@@ -425,6 +425,8 @@ def is_scalar_condition(
             return True
         if element.lineage and isinstance(element.lineage, AggregateWrapper):
             return is_scalar_condition(element.lineage, materialized)
+        if element.lineage and isinstance(element.lineage, Function):
+            return is_scalar_condition(element.lineage, materialized)
         return True
     elif isinstance(element, AggregateWrapper):
         return is_scalar_condition(element.function, materialized)

trilogy/parsing/common.py

@@ -133,7 +133,9 @@ def constant_to_concept(
     )
 
 
-def function_to_concept(parent: Function, name: str, namespace: str) -> Concept:
+def function_to_concept(
+    parent: Function, name: str, namespace: str, metadata: Metadata | None = None
+) -> Concept:
     pkeys: List[Concept] = []
     for x in parent.arguments:
         pkeys += [
@@ -159,6 +161,7 @@ def function_to_concept(parent: Function, name: str, namespace: str) -> Concept:
         purpose = Purpose.CONSTANT
     else:
         purpose = parent.output_purpose
+    fmetadata = metadata or Metadata()
     if grain is not None:
         return Concept(
             name=name,
@@ -169,6 +172,7 @@ def function_to_concept(parent: Function, name: str, namespace: str) -> Concept:
             keys=keys,
             modifiers=modifiers,
             grain=grain,
+            metadata=fmetadata,
         )
 
     return Concept(
@@ -179,6 +183,7 @@ def function_to_concept(parent: Function, name: str, namespace: str) -> Concept:
         namespace=namespace,
         keys=keys,
         modifiers=modifiers,
+        metadata=fmetadata,
     )
 
 
@@ -305,7 +310,7 @@ def arbitrary_to_concept(
     elif isinstance(parent, Function):
         if not name:
             name = f"{VIRTUAL_CONCEPT_PREFIX}_func_{parent.operator.value}_{string_to_hash(str(parent))}"
-        return function_to_concept(parent, name, namespace)
+        return function_to_concept(parent, name, namespace, metadata=metadata)
     elif isinstance(parent, ListWrapper):
         if not name:
             name = f"{VIRTUAL_CONCEPT_PREFIX}_{string_to_hash(str(parent))}"

trilogy/parsing/parse_engine.py

@@ -1,7 +1,7 @@
 from os.path import dirname, join
 from typing import List, Optional, Tuple, Union
 from re import IGNORECASE
-from lark import Lark, Transformer, v_args, Tree
+from lark import Lark, Transformer, v_args, Tree, ParseTree
 from lark.exceptions import (
     UnexpectedCharacters,
     UnexpectedEOF,
@@ -32,6 +32,7 @@ from trilogy.core.enums import (
     ShowCategory,
     FunctionClass,
     IOType,
+    ConceptSource,
 )
 from trilogy.core.exceptions import InvalidSyntaxException, UndefinedConceptException
 from trilogy.core.functions import (
@@ -126,13 +127,16 @@ from trilogy.parsing.common import (
 from dataclasses import dataclass
 
 
+CONSTANT_TYPES = (int, float, str, bool, list, ListWrapper, MapWrapper)
+
+SELF_LABEL = "root"
+
+
 @dataclass
 class WholeGrainWrapper:
     where: WhereClause
 
 
-CONSTANT_TYPES = (int, float, str, bool, list, ListWrapper, MapWrapper)
-
 with open(join(dirname(__file__), "trilogy.lark"), "r") as f:
     PARSER = Lark(
         f.read(),
@@ -144,6 +148,10 @@ with open(join(dirname(__file__), "trilogy.lark"), "r") as f:
     )
 
 
+def gen_cache_lookup(path: str, alias: str, parent: str) -> str:
+    return path + alias + parent
+
+
 def parse_concept_reference(
     name: str, environment: Environment, purpose: Optional[Purpose] = None
 ) -> Tuple[str, str, str, str | None]:
@@ -219,39 +227,47 @@ def unwrap_transformation(
 class ParseToObjects(Transformer):
     def __init__(
         self,
-        visit_tokens,
-        text,
         environment: Environment,
         parse_address: str | None = None,
+        token_address: Path | None = None,
         parsed: dict[str, "ParseToObjects"] | None = None,
+        tokens: dict[Path | str, ParseTree] | None = None,
+        text_lookup: dict[Path | str, str] | None = None,
     ):
-        Transformer.__init__(self, visit_tokens)
-        self.text = text
+        Transformer.__init__(self, True)
         self.environment: Environment = environment
-        self.parse_address = parse_address or "root"
+        self.parse_address: str = parse_address or SELF_LABEL
+        self.token_address: Path | str = token_address or SELF_LABEL
         self.parsed: dict[str, ParseToObjects] = parsed if parsed else {}
+        self.tokens: dict[Path | str, ParseTree] = tokens or {}
+        self.text_lookup: dict[Path | str, str] = text_lookup or {}
         # we do a second pass to pick up circular dependencies
         # after initial parsing
         self.pass_count = 1
-        self._results_stash = None
 
-    def transform(self, tree):
+    def set_text(self, text: str):
+        self.text_lookup[self.token_address] = text
+
+    def transform(self, tree: Tree):
         results = super().transform(tree)
-        self._results_stash = results
-        self.environment._parse_count += 1
+        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
-        reparsed = self.transform(PARSER.parse(self.text))
+        reparsed = self.transform(self.tokens[self.token_address])
         self.environment.concepts.undefined = {}
         return reparsed
 
@@ -266,6 +282,18 @@ class ParseToObjects(Transformer):
                     output.concept.metadata.description
                     or args[1].text.split("#")[1].strip()
                 )
+        if isinstance(output, ImportStatement):
+            if len(args) > 1 and isinstance(args[1], Comment):
+                comment = args[1].text.split("#")[1].strip()
+                namespace = output.alias
+                for _, v in self.environment.concepts.items():
+                    if v.namespace == namespace:
+                        if v.metadata.description:
+                            v.metadata.description = (
+                                f"{comment}: {v.metadata.description}"
+                            )
+                        else:
+                            v.metadata.description = comment
 
         return args[0]
 
@@ -647,45 +675,41 @@ class ParseToObjects(Transformer):
         return Comment(text=args.value)
 
     @v_args(meta=True)
-    def select_transform(self, meta, args) -> ConceptTransform:
+    def select_transform(self, meta: Meta, args) -> ConceptTransform:
 
         output: str = args[1]
-        function = unwrap_transformation(args[0])
+        transformation = unwrap_transformation(args[0])
         lookup, namespace, output, parent = parse_concept_reference(
             output, self.environment
         )
 
-        if isinstance(function, AggregateWrapper):
-            concept = agg_wrapper_to_concept(function, namespace=namespace, name=output)
-        elif isinstance(function, WindowItem):
-            concept = window_item_to_concept(function, namespace=namespace, name=output)
-        elif isinstance(function, FilterItem):
-            concept = filter_item_to_concept(function, namespace=namespace, name=output)
-        elif isinstance(function, CONSTANT_TYPES):
-            concept = constant_to_concept(function, namespace=namespace, name=output)
-        elif isinstance(function, Function):
-            concept = function_to_concept(function, namespace=namespace, name=output)
-        else:
-            if function.output_purpose == Purpose.PROPERTY:
-                pkeys = [x for x in function.arguments if isinstance(x, Concept)]
-                grain = Grain(components=pkeys)
-                keys = tuple(grain.components_copy)
-            else:
-                grain = None
-                keys = None
-            concept = Concept(
-                name=output,
-                datatype=function.output_datatype,
-                purpose=function.output_purpose,
-                lineage=function,
-                namespace=namespace,
-                grain=Grain(components=[]) if not grain else grain,
-                keys=keys,
+        metadata = Metadata(line_number=meta.line, concept_source=ConceptSource.SELECT)
+
+        if isinstance(transformation, AggregateWrapper):
+            concept = agg_wrapper_to_concept(
+                transformation, namespace=namespace, name=output, metadata=metadata
             )
-        if concept.metadata:
-            concept.metadata.line_number = meta.line
+        elif isinstance(transformation, WindowItem):
+            concept = window_item_to_concept(
+                transformation, namespace=namespace, name=output, metadata=metadata
+            )
+        elif isinstance(transformation, FilterItem):
+            concept = filter_item_to_concept(
+                transformation, namespace=namespace, name=output, metadata=metadata
+            )
+        elif isinstance(transformation, CONSTANT_TYPES):
+            concept = constant_to_concept(
+                transformation, namespace=namespace, name=output, metadata=metadata
+            )
+        elif isinstance(transformation, Function):
+            concept = function_to_concept(
+                transformation, namespace=namespace, name=output, metadata=metadata
+            )
+        else:
+            raise SyntaxError("Invalid transformation")
+
         self.environment.add_concept(concept, meta=meta)
-        return ConceptTransform(function=function, output=concept)
+        return ConceptTransform(function=transformation, output=concept)
 
     @v_args(meta=True)
     def concept_nullable_modifier(self, meta: Meta, args) -> Modifier:
@@ -709,7 +733,7 @@ class ParseToObjects(Transformer):
         if len(args) != 1:
             raise ParseError(
                 "Malformed select statement"
-                f" {args} {self.text[meta.start_pos:meta.end_pos]}"
+                f" {args} {self.text_lookup[self.parse_address][meta.start_pos:meta.end_pos]}"
             )
         content = args[0]
         if isinstance(content, ConceptTransform):
@@ -807,25 +831,46 @@ class ParseToObjects(Transformer):
         path = args[0].split(".")
 
         target = join(self.environment.working_path, *path) + ".preql"
-        if target in self.parsed:
-            nparser = self.parsed[target]
+
+        # tokens + text are cached by path
+        token_lookup = Path(target)
+
+        # cache lookups by the target, the alias, and the file we're importing it from
+        cache_lookup = gen_cache_lookup(
+            path=target, alias=alias, parent=str(self.token_address)
+        )
+        if token_lookup in self.tokens:
+            raw_tokens = self.tokens[token_lookup]
+            text = self.text_lookup[token_lookup]
+        else:
+            text = self.resolve_import_address(target)
+            self.text_lookup[token_lookup] = text
+
+            raw_tokens = PARSER.parse(text)
+            self.tokens[token_lookup] = raw_tokens
+
+        if cache_lookup in self.parsed:
+            nparser = self.parsed[cache_lookup]
         else:
             try:
-                text = self.resolve_import_address(target)
+                new_env = Environment(
+                    working_path=dirname(target),
+                )
+                new_env.concepts.fail_on_missing = False
                 nparser = ParseToObjects(
-                    visit_tokens=True,
-                    text=text,
-                    environment=Environment(
-                        working_path=dirname(target),
-                        # namespace=alias,
-                    ),
-                    parse_address=target,
+                    environment=new_env,
+                    parse_address=cache_lookup,
+                    token_address=token_lookup,
                     parsed={**self.parsed, **{self.parse_address: self}},
+                    tokens={**self.tokens, **{token_lookup: raw_tokens}},
+                    text_lookup={**self.text_lookup, **{token_lookup: text}},
                 )
-                nparser.transform(PARSER.parse(text))
-                self.parsed[target] = nparser
+                nparser.transform(raw_tokens)
+                self.parsed[cache_lookup] = nparser
                 # add the parsed objects of the import in
                 self.parsed = {**self.parsed, **nparser.parsed}
+                self.tokens = {**self.tokens, **nparser.tokens}
+                self.text_lookup = {**self.text_lookup, **nparser.text_lookup}
             except Exception as e:
                 raise ImportError(f"Unable to import file {target}, parsing error: {e}")
 
@@ -1912,11 +1957,14 @@ def parse_text(text: str, environment: Optional[Environment] = None) -> Tuple[
     ],
 ]:
     environment = environment or Environment()
-    parser = ParseToObjects(visit_tokens=True, text=text, 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: