pytrilogy 0.0.3.5__py3-none-any.whl → 0.0.3.7__py3-none-any.whl

{pytrilogy-0.0.3.5.dist-info → pytrilogy-0.0.3.7.dist-info}/METADATA

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

{pytrilogy-0.0.3.5.dist-info → pytrilogy-0.0.3.7.dist-info}/RECORD

@@ -1,8 +1,8 @@
-trilogy/__init__.py,sha256=7rK8M4Aw3BDqS9a5ou3PjyRkVMzEhaVMf6a7V-8ll4E,302
+trilogy/__init__.py,sha256=nCVrjnf_bl_zZ7GmePdSoaRQ40QxFDkSFlafhQp8Cn8,302
 trilogy/compiler.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/constants.py,sha256=qZ1d0hoKPPV2HHCoFwPYTVB7b6bXjpWvXd3lE-zEhy8,1494
-trilogy/engine.py,sha256=yOPnR7XCjWG82Gym_LLZBkYKKJdLCvqdCyt8zguNcnM,1103
-trilogy/executor.py,sha256=sssEPDnIDPiQtMSrt5pFiJXUfcDc6gSi4m2Eliod_BM,16844
+trilogy/engine.py,sha256=3etkm2RSVKO0IkgPKkrcs33X5gN_fIMyqMNfChcsR1E,1318
+trilogy/executor.py,sha256=YgSCeeYVecI9526LGSLVe2apOo7Ddsttvs_nDC9yElQ,17194
 trilogy/parser.py,sha256=o4cfk3j3yhUFoiDKq9ZX_GjBF3dKhDjXEwb63rcBkBM,293
 trilogy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/utility.py,sha256=euQccZLKoYBz0LNg5tzLlvv2YHvXh9HArnYp1V3uXsM,763
@@ -14,7 +14,7 @@ trilogy/core/env_processor.py,sha256=pFsxnluKIusGKx1z7tTnfsd_xZcPy9pZDungkjkyvI0
 trilogy/core/environment_helpers.py,sha256=oOpewPwMp8xOtx2ayeeyuLNUwr-cli7UanHKot5ebNY,7627
 trilogy/core/ergonomics.py,sha256=ASLDd0RqKWrZiG3XcKHo8nyTjaB_8xfE9t4NZ1UvGpc,1639
 trilogy/core/exceptions.py,sha256=JPYyBcit3T_pRtlHdtKSeVJkIyWUTozW2aaut25A2xI,673
-trilogy/core/functions.py,sha256=7Pq9jYSJd45L2pxT7AI-_rXVZmeLnmTPp8d1lA4z4Vk,24440
+trilogy/core/functions.py,sha256=rIkZGzw9hpIkXvuqQ1qPWFJO1W_NPYc6T9t0wTZ55M0,24784
 trilogy/core/graph_models.py,sha256=z17EoO8oky2QOuO6E2aMWoVNKEVJFhLdsQZOhC4fNLU,2079
 trilogy/core/internal.py,sha256=iicDBlC6nM8d7e7jqzf_ZOmpUsW8yrr2AA8AqEiLx-s,1577
 trilogy/core/optimization.py,sha256=xGO8piVsLrpqrx-Aid_Y56_5slSv4eZmlP64hCHRiEc,7957
@@ -24,8 +24,8 @@ trilogy/core/models/author.py,sha256=oRCKWhz-i1fO1LlHWiHE3l1awCHdQ3yx6FKH9n9RxRU
 trilogy/core/models/build.py,sha256=kiq31T8LtUtgmT37m617Q2MlMvQTuAxJzwb6947EiWU,56127
 trilogy/core/models/build_environment.py,sha256=8UggvlPU708GZWYPJMc_ou2r7M3TY2g69eqGvz03YX0,5528
 trilogy/core/models/core.py,sha256=yie1uuq62uOQ5fjob9NMJbdvQPrCErXUT7JTCuYRyjI,9697
-trilogy/core/models/datasource.py,sha256=c0tGxyH2WwTmAD047tr69U0a6GNVf-ug26H68yii7DA,9257
-trilogy/core/models/environment.py,sha256=GU8D3cn6lCFAseVPYfW_a-cnBbD1sYEeDVOkbZSWCxk,25943
+trilogy/core/models/datasource.py,sha256=6RjJUd2u4nYmEwFBpJlM9LbHVYDv8iHJxqiBMZqUrwI,9422
+trilogy/core/models/environment.py,sha256=h06y1Dv7naw2GuFFAAyoFZmicG7a7Lu-dRoYPVfrOGo,25967
 trilogy/core/models/execute.py,sha256=ABylFQgtavjjCfFkEsFdUwfMB4UBQLHjdzQ9E67QlAE,33521
 trilogy/core/optimizations/__init__.py,sha256=EBanqTXEzf1ZEYjAneIWoIcxtMDite5-n2dQ5xcfUtg,356
 trilogy/core/optimizations/base_optimization.py,sha256=gzDOKImoFn36k7XBD3ysEYDnbnb6vdVIztUfFQZsGnM,513
@@ -71,9 +71,10 @@ trilogy/dialect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/dialect/base.py,sha256=u00kIIl98as1QzcduiiyyoBzxRGVeBxfeO5hWlRCAJU,40222
 trilogy/dialect/bigquery.py,sha256=mKC3zoEU232h9RtIXJjqiZ72lWH8a6S28p6wAZKrAfg,2952
 trilogy/dialect/common.py,sha256=cbTo_vamdp8pj9spSjGSH-bSZpy4FpNJ12k5vMvyT2Y,3942
-trilogy/dialect/config.py,sha256=UiBY2tBbNk9owx-zxP_3lN9lErEUXhXIU_bcXA18AvU,2992
+trilogy/dialect/config.py,sha256=e-ZDVh7Z648JYz85JwSobTyo2cTi4lYGFMglZzB7atM,3184
+trilogy/dialect/dataframe.py,sha256=ei5y91XyZHI3ydUbdQ2sInnw2qHGtgb21DNX6qff0xw,1419
 trilogy/dialect/duckdb.py,sha256=2tH_OetgLJoKf_f4bdeeB0ozGC8f0h_xQ271I8qD-Oo,3690
-trilogy/dialect/enums.py,sha256=JICGp0KQhxNuVDSU36mve2XTZLbPpFRWUDkjvwni4eM,3979
+trilogy/dialect/enums.py,sha256=1KDgds_DC31hGxZzNI_TIggxXF7m9rIjn9KLgNf5WQU,4425
 trilogy/dialect/postgres.py,sha256=VH4EB4myjIeZTHeFU6vK00GxY9c53rCBjg2mLbdaCEE,3254
 trilogy/dialect/presto.py,sha256=bAxaDcLL21fivPg7hmBd3HJmd0yYJdPdwNgNA5ga7DE,3391
 trilogy/dialect/snowflake.py,sha256=wmao9p26jX5yIX5SC8sRAZTXkPGTvq6ixO693QTfhz8,2989
@@ -88,14 +89,14 @@ trilogy/parsing/common.py,sha256=yAE3x4SyO4PfAb7HhZ_l9sNPYaf_pcM1K8ioEy76SCU,203
 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=uazcnUhY3pERY8Xa116IHl1JhCPSlvQG6i4vP7I4Qpk,54638
+trilogy/parsing/parse_engine.py,sha256=32_yO_SreTjHxCkMziW2re15ilEZn01OUizVAvN9xHo,54656
 trilogy/parsing/render.py,sha256=o_XuQWhcwx1lD9eGVqkqZEwkmQK0HdmWWokGBtdeH4I,17837
 trilogy/parsing/trilogy.lark,sha256=EazfEvYPuvkPkNjUnVzFi0uD9baavugbSI8CyfawShk,12573
 trilogy/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/scripts/trilogy.py,sha256=1L0XrH4mVHRt1C9T1HnaDv2_kYEfbWTb5_-cBBke79w,3774
-pytrilogy-0.0.3.5.dist-info/LICENSE.md,sha256=5ZRvtTyCCFwz1THxDTjAu3Lidds9WjPvvzgVwPSYNDo,1042
-pytrilogy-0.0.3.5.dist-info/METADATA,sha256=W8SsLe2qtgpl4SDr_xlL3lOwReWbKYBClHXkjLQSIqk,8983
-pytrilogy-0.0.3.5.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-pytrilogy-0.0.3.5.dist-info/entry_points.txt,sha256=0petKryjvvtEfTlbZC1AuMFumH_WQ9v8A19LvoS6G6c,54
-pytrilogy-0.0.3.5.dist-info/top_level.txt,sha256=cAy__NW_eMAa_yT9UnUNlZLFfxcg6eimUAZ184cdNiE,8
-pytrilogy-0.0.3.5.dist-info/RECORD,,
+pytrilogy-0.0.3.7.dist-info/LICENSE.md,sha256=5ZRvtTyCCFwz1THxDTjAu3Lidds9WjPvvzgVwPSYNDo,1042
+pytrilogy-0.0.3.7.dist-info/METADATA,sha256=wvr0oUtX0As37OC9ljg5XnV7rblzMNvUppA4il2PtPI,8983
+pytrilogy-0.0.3.7.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+pytrilogy-0.0.3.7.dist-info/entry_points.txt,sha256=0petKryjvvtEfTlbZC1AuMFumH_WQ9v8A19LvoS6G6c,54
+pytrilogy-0.0.3.7.dist-info/top_level.txt,sha256=cAy__NW_eMAa_yT9UnUNlZLFfxcg6eimUAZ184cdNiE,8
+pytrilogy-0.0.3.7.dist-info/RECORD,,

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

trilogy/core/functions.py

@@ -503,32 +503,52 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
         arg_count=1,
     ),
     FunctionType.ADD: FunctionConfig(
-        valid_inputs={DataType.INTEGER, DataType.FLOAT, DataType.NUMBER},
+        valid_inputs={
+            DataType.INTEGER,
+            DataType.FLOAT,
+            DataType.NUMBER,
+            DataType.NUMERIC,
+        },
         output_purpose=Purpose.PROPERTY,
         output_type=DataType.INTEGER,
         arg_count=InfiniteFunctionArgs,
     ),
     FunctionType.SUBTRACT: FunctionConfig(
-        valid_inputs={DataType.INTEGER, DataType.FLOAT, DataType.NUMBER},
+        valid_inputs={
+            DataType.INTEGER,
+            DataType.FLOAT,
+            DataType.NUMBER,
+            DataType.NUMERIC,
+        },
         output_purpose=Purpose.PROPERTY,
         output_type=DataType.INTEGER,
         arg_count=InfiniteFunctionArgs,
     ),
     FunctionType.MULTIPLY: FunctionConfig(
-        valid_inputs={DataType.INTEGER, DataType.FLOAT, DataType.NUMBER},
+        valid_inputs={
+            DataType.INTEGER,
+            DataType.FLOAT,
+            DataType.NUMBER,
+            DataType.NUMERIC,
+        },
         output_purpose=Purpose.PROPERTY,
         output_type=DataType.INTEGER,
         arg_count=InfiniteFunctionArgs,
     ),
     FunctionType.DIVIDE: FunctionConfig(
-        valid_inputs={DataType.INTEGER, DataType.FLOAT, DataType.NUMBER},
+        valid_inputs={
+            DataType.INTEGER,
+            DataType.FLOAT,
+            DataType.NUMBER,
+            DataType.NUMERIC,
+        },
         output_purpose=Purpose.PROPERTY,
         output_type=DataType.INTEGER,
         arg_count=InfiniteFunctionArgs,
     ),
     FunctionType.MOD: FunctionConfig(
         valid_inputs=[
-            {DataType.INTEGER, DataType.FLOAT, DataType.NUMBER},
+            {DataType.INTEGER, DataType.FLOAT, DataType.NUMBER, DataType.NUMERIC},
             {DataType.INTEGER},
         ],
         output_purpose=Purpose.PROPERTY,
@@ -537,7 +557,7 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
     ),
     FunctionType.ROUND: FunctionConfig(
         valid_inputs=[
-            {DataType.INTEGER, DataType.FLOAT, DataType.NUMBER},
+            {DataType.INTEGER, DataType.FLOAT, DataType.NUMBER, DataType.NUMERIC},
             {DataType.INTEGER},
         ],
         output_purpose=Purpose.PROPERTY,

trilogy/core/models/datasource.py

@@ -117,6 +117,12 @@ class Datasource(HasUUID, Namespaced, BaseModel):
     where: Optional[WhereClause] = None
     non_partial_for: Optional[WhereClause] = None
 
+    @property
+    def safe_address(self) -> str:
+        if isinstance(self.address, Address):
+            return self.address.location
+        return self.address
+
     def __eq__(self, other):
         if not isinstance(other, Datasource):
             return False

trilogy/core/models/environment.py

@@ -426,7 +426,6 @@ class Environment(BaseModel):
         from trilogy.parsing.parse_engine import (
             PARSER,
             ParseToObjects,
-            gen_cache_lookup,
         )
 
         if isinstance(path, str):
@@ -440,7 +439,8 @@ class Environment(BaseModel):
         else:
             target = path
         if not env:
-            parse_address = gen_cache_lookup(str(target), alias, str(self.working_path))
+            import_keys = ["root", alias]
+            parse_address = "-".join(import_keys)
             try:
                 with open(target, "r", encoding="utf-8") as f:
                     text = f.read()
@@ -454,11 +454,12 @@ class Environment(BaseModel):
                     ),
                     parse_address=parse_address,
                     token_address=target,
+                    import_keys=import_keys,
                 )
                 nparser.set_text(text)
                 nparser.environment.concepts.fail_on_missing = False
                 nparser.transform(PARSER.parse(text))
-                nparser.hydrate_missing()
+                nparser.run_second_parse_pass()
                 nparser.environment.concepts.fail_on_missing = True
 
             except Exception as e:

trilogy/dialect/config.py

@@ -1,3 +1,6 @@
+from pandas import DataFrame
+
+
 class DialectConfig:
     def __init__(self):
         pass
@@ -104,3 +107,9 @@ class TrinoConfig(PrestoConfig):
         if self.schema:
             return f"trino://{self.username}:{self.password}@{self.host}:{self.port}/{self.catalog}/{self.schema}"
         return f"trino://{self.username}:{self.password}@{self.host}:{self.port}/{self.catalog}"
+
+
+class DataFrameConfig(DuckDBConfig):
+    def __init__(self, dataframes: dict[str, DataFrame]):
+        super().__init__()
+        self.dataframes = dataframes

trilogy/dialect/dataframe.py

@@ -0,0 +1,42 @@
+from typing import Any
+
+from pandas import DataFrame
+from sqlalchemy import text
+
+from trilogy.core.models.environment import Environment
+from trilogy.dialect.duckdb import DuckDBDialect
+from trilogy.engine import ExecutionEngine
+
+
+class DataframeDialect(DuckDBDialect):
+    pass
+
+
+class DataframeConnectionWrapper(ExecutionEngine):
+    def __init__(self, engine: ExecutionEngine, dataframes: dict[str, DataFrame]):
+        self.engine = engine
+        self.dataframes = dataframes
+        self.connection = None
+
+    def setup(self, env: Environment, connection):
+        self._register_dataframes(env, connection)
+
+    def _register_dataframes(self, env: Environment, connection):
+        for ds in env.datasources.values():
+            if ds.safe_address in self.dataframes:
+                connection.execute(
+                    text("register(:name, :df)"),
+                    {"name": ds.safe_address, "df": self.dataframes[ds.safe_address]},
+                )
+            else:
+                raise ValueError(
+                    f"Dataframe {ds.safe_address} not found in dataframes on connection config, have {self.dataframes.keys()}"
+                )
+        pass
+
+    def add_dataframe(self, name: str, df: DataFrame, connection, env: Environment):
+        self.dataframes[name] = df
+        self._register_dataframes(env, connection)
+
+    def connect(self) -> Any:
+        return self.engine.connect()

trilogy/dialect/enums.py

@@ -16,7 +16,7 @@ def default_factory(conf: DialectConfig, config_type):
 
     if not isinstance(conf, config_type):
         raise TypeError(
-            f"Invalid dialect configuration for type {type(config_type).__name__}"
+            f"Invalid dialect configuration for type {type(config_type).__name__}, is {type(conf)}"
         )
     if conf.connect_args:
         return create_engine(
@@ -33,6 +33,7 @@ class Dialects(Enum):
     TRINO = "trino"
     POSTGRES = "postgres"
     SNOWFLAKE = "snowflake"
+    DATAFRAME = "dataframe"
 
     @classmethod
     def _missing_(cls, value):
@@ -88,6 +89,16 @@ class Dialects(Enum):
             from trilogy.dialect.config import TrinoConfig
 
             return _engine_factory(conf, TrinoConfig)
+        elif self == Dialects.DATAFRAME:
+            from trilogy.dialect.config import DataFrameConfig
+            from trilogy.dialect.dataframe import DataframeConnectionWrapper
+
+            if not conf:
+                conf = DataFrameConfig(dataframes={})
+
+            base = _engine_factory(conf, DataFrameConfig)
+
+            return DataframeConnectionWrapper(base, dataframes=conf.dataframes)
         else:
             raise ValueError(
                 f"Unsupported dialect {self} for default engine creation; create one explicitly."

trilogy/engine.py

@@ -1,7 +1,9 @@
-from typing import Protocol
+from typing import Any, Protocol
 
 from sqlalchemy.engine import Connection, CursorResult, Engine
 
+from trilogy.core.models.environment import Environment
+
 
 class EngineResult(Protocol):
     pass
@@ -13,7 +15,7 @@ class EngineResult(Protocol):
 class EngineConnection(Protocol):
     pass
 
-    def execute(self, statement: str) -> EngineResult:
+    def execute(self, statement: str, parameters: Any | None = None) -> EngineResult:
         pass
 
 
@@ -23,6 +25,9 @@ class ExecutionEngine(Protocol):
     def connect(self) -> EngineConnection:
         pass
 
+    def setup(self, env: Environment, connection):
+        pass
+
 
 ### Begin default SQLAlchemy implementation
 class SqlAlchemyResult(EngineResult):
@@ -37,8 +42,10 @@ class SqlAlchemyConnection(EngineConnection):
     def __init__(self, connection: Connection):
         self.connection = connection
 
-    def execute(self, statement: str) -> SqlAlchemyResult:
-        return SqlAlchemyResult(self.connection.execute(statement))
+    def execute(
+        self, statement: str, parameters: Any | None = None
+    ) -> SqlAlchemyResult:
+        return SqlAlchemyResult(self.connection.execute(statement, parameters))
 
 
 class SqlAlchemyEngine(ExecutionEngine):

trilogy/executor.py

@@ -4,7 +4,7 @@ from pathlib import Path
 from typing import Any, Generator, List, Optional, Protocol
 
 from sqlalchemy import text
-from sqlalchemy.engine import CursorResult, Engine
+from sqlalchemy.engine import CursorResult
 
 from trilogy.constants import logger
 from trilogy.core.enums import FunctionType, Granularity, IOType
@@ -33,6 +33,7 @@ from trilogy.core.statements.execute import (
 )
 from trilogy.dialect.base import BaseDialect
 from trilogy.dialect.enums import Dialects
+from trilogy.engine import ExecutionEngine
 from trilogy.hooks.base_hook import BaseHook
 from trilogy.parser import parse_text
 
@@ -71,7 +72,7 @@ class Executor(object):
     def __init__(
         self,
         dialect: Dialects,
-        engine: Engine,
+        engine: ExecutionEngine,
         environment: Optional[Environment] = None,
         hooks: List[BaseHook] | None = None,
     ):
@@ -109,9 +110,16 @@ class Executor(object):
             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.connection = self.engine.connect()
+        # TODO: make generic
+        if self.dialect == Dialects.DATAFRAME:
+            self.engine.setup(self.environment, self.connection)
 
     def execute_statement(self, statement) -> Optional[CursorResult]:
         if not isinstance(

trilogy/parsing/parse_engine.py

@@ -129,6 +129,8 @@ CONSTANT_TYPES = (int, float, str, bool, list, ListWrapper, MapWrapper)
 
 SELF_LABEL = "root"
 
+MAX_PARSE_DEPTH = 10
+
 
 @dataclass
 class WholeGrainWrapper:
@@ -146,13 +148,6 @@ 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
-
-
 def parse_concept_reference(
     name: str, environment: Environment, purpose: Optional[Purpose] = None
 ) -> Tuple[str, str, str, str | None]:
@@ -226,6 +221,8 @@ class ParseToObjects(Transformer):
         parsed: dict[str, "ParseToObjects"] | None = None,
         tokens: dict[Path | str, ParseTree] | None = None,
         text_lookup: dict[Path | str, str] | None = None,
+        environment_lookup: dict[str, Environment] | None = None,
+        import_keys: list[str] | None = None,
     ):
         Transformer.__init__(self, True)
         self.environment: Environment = environment
@@ -233,6 +230,7 @@ class ParseToObjects(Transformer):
         self.token_address: Path | str = token_address or SELF_LABEL
         self.parsed: dict[str, ParseToObjects] = parsed if parsed is not None else {}
         self.tokens: dict[Path | str, ParseTree] = tokens if tokens is not None else {}
+        self.environments: dict[str, Environment] = environment_lookup or {}
         self.text_lookup: dict[Path | str, str] = (
             text_lookup if text_lookup is not None else {}
         )
@@ -240,6 +238,7 @@ class ParseToObjects(Transformer):
         # after initial parsing
         self.parse_pass = ParsePass.INITIAL
         self.function_factory = FunctionFactory(self.environment)
+        self.import_keys: list[str] = import_keys or ["root"]
 
     def set_text(self, text: str):
         self.text_lookup[self.token_address] = text
@@ -255,14 +254,14 @@ class ParseToObjects(Transformer):
         for _, v in self.parsed.items():
             v.prepare_parse()
 
-    def hydrate_missing(self, force: bool = False):
+    def run_second_parse_pass(self, force: bool = False):
         if self.token_address not in self.tokens:
             return []
         self.parse_pass = ParsePass.VALIDATION
         for _, v in list(self.parsed.items()):
-            if v.parse_pass == ParsePass.VALIDATION and not force:
+            if v.parse_pass == ParsePass.VALIDATION:
                 continue
-            v.hydrate_missing()
+            v.run_second_parse_pass()
         reparsed = self.transform(self.tokens[self.token_address])
         self.environment.concepts.undefined = {}
         return reparsed
@@ -306,11 +305,6 @@ class ParseToObjects(Transformer):
     def QUOTED_IDENTIFIER(self, args) -> str:
         return args.value[1:-1]
 
-    # @v_args(meta=True)
-    # def concept_lit(self, meta: Meta, args) -> ConceptRef:
-    #     address = args[0]
-    #     return self.environment.concepts.__getitem__(address, meta.line)
-    #     return ConceptRef(address=address, line_no=meta.line)
     @v_args(meta=True)
     def concept_lit(self, meta: Meta, args) -> ConceptRef:
         address = args[0]
@@ -402,7 +396,6 @@ 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
         )
@@ -858,8 +851,10 @@ class ParseToObjects(Transformer):
     def import_statement(self, args: list[str]) -> ImportStatement:
         if len(args) == 2:
             alias = args[-1]
+            cache_key = args[-1]
         else:
             alias = self.environment.namespace
+            cache_key = args[0]
         path = args[0].split(".")
 
         target = join(self.environment.working_path, *path) + ".preql"
@@ -867,10 +862,14 @@ class ParseToObjects(Transformer):
         # 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)
-        )
+        # parser + env has to be cached by prior import path + current key
+        key_path = self.import_keys + [cache_key]
+        cache_lookup = "-".join(key_path)
+
+        # we don't iterate past the max parse depth
+        if len(key_path) > MAX_PARSE_DEPTH:
+            return ImportStatement(alias=alias, path=Path(target))
+
         if token_lookup in self.tokens:
             raw_tokens = self.tokens[token_lookup]
             text = self.text_lookup[token_lookup]
@@ -886,7 +885,7 @@ class ParseToObjects(Transformer):
             new_env = nparser.environment
             if nparser.parse_pass != ParsePass.VALIDATION:
                 # nparser.transform(raw_tokens)
-                nparser.hydrate_missing()
+                nparser.run_second_parse_pass()
         else:
             try:
                 new_env = Environment(
@@ -902,6 +901,7 @@ class ParseToObjects(Transformer):
                     parsed=self.parsed,
                     tokens=self.tokens,
                     text_lookup=self.text_lookup,
+                    import_keys=self.import_keys + [cache_key],
                 )
                 nparser.transform(raw_tokens)
                 self.parsed[cache_lookup] = nparser
@@ -909,6 +909,7 @@ 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)
 
@@ -1621,7 +1622,7 @@ def parse_text(
     environment = environment or (
         Environment(working_path=root) if root else Environment()
     )
-    parser = ParseToObjects(environment=environment)
+    parser = ParseToObjects(environment=environment, import_keys=["root"])
 
     try:
         parser.set_text(text)
@@ -1629,7 +1630,7 @@ def parse_text(
         parser.prepare_parse()
         parser.transform(PARSER.parse(text))
         # this will reset fail on missing
-        pass_two = parser.hydrate_missing(force=True)
+        pass_two = parser.run_second_parse_pass()
         output = [v for v in pass_two if v]
         environment.concepts.fail_on_missing = True
     except VisitError as e: