awx-zipline-ai 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

agent/ttypes.py

@@ -12,7 +12,7 @@ from thrift.TRecursive import fix_spec
 from uuid import UUID
 
 import sys
-import ai.chronon.api.common.ttypes
+import gen_thrift.common.ttypes
 
 from thrift.transport import TTransport
 all_structs = []
@@ -39,7 +39,7 @@ class JobStatusType(object):
     RUNNING = 2
     SUCCEEDED = 3
     FAILED = 4
-    STOPPED = 5
+    CANCELLED = 5
 
     _VALUES_TO_NAMES = {
         0: "UNKNOWN",
@@ -47,7 +47,7 @@ class JobStatusType(object):
         2: "RUNNING",
         3: "SUCCEEDED",
         4: "FAILED",
-        5: "STOPPED",
+        5: "CANCELLED",
     }
 
     _NAMES_TO_VALUES = {
@@ -56,7 +56,7 @@ class JobStatusType(object):
         "RUNNING": 2,
         "SUCCEEDED": 3,
         "FAILED": 4,
-        "STOPPED": 5,
+        "CANCELLED": 5,
     }
 
 
@@ -1388,7 +1388,7 @@ class PartitionListingPutRequest(object):
                         _val84 = []
                         (_etype88, _size85) = iprot.readListBegin()
                         for _i89 in range(_size85):
-                            _elem90 = ai.chronon.api.common.ttypes.DateRange()
+                            _elem90 = gen_thrift.common.ttypes.DateRange()
                             _elem90.read(iprot)
                             _val84.append(_elem90)
                         iprot.readListEnd()
@@ -1672,7 +1672,7 @@ JobInfo.thrift_spec = (
 all_structs.append(PartitionListingPutRequest)
 PartitionListingPutRequest.thrift_spec = (
     None,  # 0
-    (1, TType.MAP, 'partitions', (TType.STRUCT, [PartitionListingJob, None], TType.LIST, (TType.STRUCT, [ai.chronon.api.common.ttypes.DateRange, None], False), False), None, ),  # 1
+    (1, TType.MAP, 'partitions', (TType.STRUCT, [PartitionListingJob, None], TType.LIST, (TType.STRUCT, [gen_thrift.common.ttypes.DateRange, None], False), False), None, ),  # 1
     (2, TType.MAP, 'errors', (TType.STRUCT, [PartitionListingJob, None], TType.STRING, 'UTF8', False), None, ),  # 2
 )
 all_structs.append(JobInfoPutRequest)

ai/chronon/airflow_helpers.py

@@ -2,9 +2,10 @@ import json
 import math
 from typing import OrderedDict
 
+from gen_thrift.api.ttypes import GroupBy, Join
+from gen_thrift.common.ttypes import TimeUnit
+
 import ai.chronon.utils as utils
-from ai.chronon.api.common.ttypes import TimeUnit
-from ai.chronon.api.ttypes import GroupBy, Join
 from ai.chronon.constants import (
     AIRFLOW_DEPENDENCIES_KEY,
     AIRFLOW_LABEL_DEPENDENCIES_KEY,
@@ -55,6 +56,7 @@ def _get_partition_col_from_query(query):
         return query.partitionColumn
     return None
 
+
 def _get_additional_subPartitionsToWaitFor_from_query(query):
     """Gets additional subPartitionsToWaitFor from query if available"""
     if query:
@@ -80,7 +82,8 @@ def _get_airflow_deps_from_source(source, partition_column=None):
         tables = [source.events.table]
         # Use partition column from query if available, otherwise use the provided one
         source_partition_column, additional_partitions = (
-            _get_partition_col_from_query(source.events.query) or partition_column, _get_additional_subPartitionsToWaitFor_from_query(source.events.query)
+            _get_partition_col_from_query(source.events.query) or partition_column,
+            _get_additional_subPartitionsToWaitFor_from_query(source.events.query),
         )
 
     elif source.entities:
@@ -89,7 +92,8 @@ def _get_airflow_deps_from_source(source, partition_column=None):
         if source.entities.mutationTable:
             tables.append(source.entities.mutationTable)
         source_partition_column, additional_partitions = (
-            _get_partition_col_from_query(source.entities.query) or partition_column, _get_additional_subPartitionsToWaitFor_from_query(source.entities.query)
+            _get_partition_col_from_query(source.entities.query) or partition_column,
+            _get_additional_subPartitionsToWaitFor_from_query(source.entities.query),
         )
     elif source.joinSource:
         # TODO: Handle joinSource -- it doesn't work right now because the metadata isn't set on joinSource at this point
@@ -99,15 +103,14 @@ def _get_airflow_deps_from_source(source, partition_column=None):
         return []
 
     return [
-        create_airflow_dependency(table, source_partition_column, additional_partitions) for table in tables
+        create_airflow_dependency(table, source_partition_column, additional_partitions)
+        for table in tables
     ]
 
 
 def extract_default_partition_column(obj):
     try:
-        return obj.metaData.executionInfo.conf.common.get(
-            "spark.chronon.partition.column"
-        )
+        return obj.metaData.executionInfo.conf.common.get("spark.chronon.partition.column")
     except Exception:
         # Error handling occurs in `create_airflow_dependency`
         return None
@@ -124,9 +127,9 @@ def _get_distinct_day_windows(group_by):
                 if time_unit == TimeUnit.DAYS:
                     windows.append(length)
                 elif time_unit == TimeUnit.HOURS:
-                    windows.append(math.ceil(length/24))
+                    windows.append(math.ceil(length / 24))
                 elif time_unit == TimeUnit.MINUTES:
-                    windows.append(math.ceil(length/(24*60)))
+                    windows.append(math.ceil(length / (24 * 60)))
     return set(windows)
 
 
@@ -137,9 +140,7 @@ def _set_join_deps(join):
 
     # Handle left source
     left_query = utils.get_query(join.left)
-    left_partition_column = (
-        _get_partition_col_from_query(left_query) or default_partition_col
-    )
+    left_partition_column = _get_partition_col_from_query(left_query) or default_partition_col
     deps.extend(_get_airflow_deps_from_source(join.left, left_partition_column))
 
     # Handle right parts (join parts)
@@ -149,12 +150,9 @@ def _set_join_deps(join):
                 for source in join_part.groupBy.sources:
                     source_query = utils.get_query(source)
                     source_partition_column = (
-                        _get_partition_col_from_query(source_query)
-                        or default_partition_col
-                    )
-                    deps.extend(
-                        _get_airflow_deps_from_source(source, source_partition_column)
+                        _get_partition_col_from_query(source_query) or default_partition_col
                     )
+                    deps.extend(_get_airflow_deps_from_source(source, source_partition_column))
 
     label_deps = []
     # Handle label parts
@@ -162,7 +160,6 @@ def _set_join_deps(join):
         join_output_table = utils.output_table_name(join, full_name=True)
         partition_column = join.metaData.executionInfo.conf.common[PARTITION_COLUMN_KEY]
 
-
         # set the dependencies on the label sources
         for label_part in join.labelParts.labels:
             group_by = label_part.groupBy
@@ -171,21 +168,21 @@ def _set_join_deps(join):
             windows = _get_distinct_day_windows(group_by)
             for window in windows:
                 label_deps.append(
-                    create_airflow_dependency(join_output_table, partition_column, offset=-1 * window)
+                    create_airflow_dependency(
+                        join_output_table, partition_column, offset=-1 * window
+                    )
                 )
 
             if group_by and group_by.sources:
                 for source in label_part.groupBy.sources:
                     source_query = utils.get_query(source)
                     source_partition_column = (
-                        _get_partition_col_from_query(source_query)
-                        or default_partition_col
+                        _get_partition_col_from_query(source_query) or default_partition_col
                     )
                     label_deps.extend(
                         _get_airflow_deps_from_source(source, source_partition_column)
                     )
 
-
     # Update the metadata customJson with dependencies
     _dedupe_and_set_airflow_deps_json(join, deps, AIRFLOW_DEPENDENCIES_KEY)
 

ai/chronon/cli/compile/column_hashing.py

@@ -3,12 +3,15 @@ import re
 from collections import defaultdict
 from typing import Dict, List
 
-from ai.chronon.api.ttypes import Derivation, ExternalPart, GroupBy, Join, Source
+from gen_thrift.api.ttypes import Derivation, ExternalPart, GroupBy, Join, Source
+
 from ai.chronon.group_by import get_output_col_names
 
 
 # Returns a map of output column to semantic hash, including derivations
-def compute_group_by_columns_hashes(group_by: GroupBy, exclude_keys: bool = False) -> Dict[str, str]:
+def compute_group_by_columns_hashes(
+    group_by: GroupBy, exclude_keys: bool = False
+) -> Dict[str, str]:
     """
     From the group_by object, get the final output columns after derivations.
     """
@@ -24,7 +27,7 @@ def compute_group_by_columns_hashes(group_by: GroupBy, exclude_keys: bool = Fals
     group_by_minor_version_suffix = f"__{group_by.metaData.version}"
     group_by_major_version = group_by.metaData.name
     if group_by_major_version.endswith(group_by_minor_version_suffix):
-        group_by_major_version = group_by_major_version[:-len(group_by_minor_version_suffix)]
+        group_by_major_version = group_by_major_version[: -len(group_by_minor_version_suffix)]
     base_semantics.append(f"group_by_name:{group_by_major_version}")
 
     # Compute the semantic hash for each output column
@@ -87,7 +90,9 @@ def get_pre_derived_source_keys(source: Source) -> Dict[str, str]:
     base_semantics = _extract_source_semantic_info(source)
     source_keys_to_hashes = {}
     for key, expression in extract_selects(source).items():
-        source_keys_to_hashes[key] = _compute_semantic_hash(base_semantics + [f"select:{key}={expression}"])
+        source_keys_to_hashes[key] = _compute_semantic_hash(
+            base_semantics + [f"select:{key}={expression}"]
+        )
     return source_keys_to_hashes
 
 
@@ -101,7 +106,6 @@ def extract_selects(source: Source) -> Dict[str, str]:
 
 
 def get_pre_derived_join_internal_features(join: Join) -> Dict[str, str]:
-
     # Get the base semantic fields from join left side (without key columns)
     join_base_semantic_fields = _extract_source_semantic_info(join.left)
 
@@ -109,7 +113,9 @@ def get_pre_derived_join_internal_features(join: Join) -> Dict[str, str]:
     for jp in join.joinParts:
         # Build key mapping semantics - include left side key expressions
         if jp.keyMapping:
-            key_mapping_semantics = ["join_keys:" + ",".join(f"{k}:{v}" for k, v in sorted(jp.keyMapping.items()))]
+            key_mapping_semantics = [
+                "join_keys:" + ",".join(f"{k}:{v}" for k, v in sorted(jp.keyMapping.items()))
+            ]
         else:
             key_mapping_semantics = []
 
@@ -133,7 +139,9 @@ def get_pre_derived_join_internal_features(join: Join) -> Dict[str, str]:
         # These semantics apply to all features in the joinPart
         jp_base_semantics = key_mapping_semantics + left_key_expressions + join_base_semantic_fields
 
-        pre_derived_group_by_features = get_pre_derived_group_by_features(jp.groupBy, jp_base_semantics)
+        pre_derived_group_by_features = get_pre_derived_group_by_features(
+            jp.groupBy, jp_base_semantics
+        )
 
         if jp.groupBy.derivations:
             derived_group_by_features = build_derived_columns(
@@ -164,7 +172,9 @@ def get_pre_derived_group_by_columns(group_by: GroupBy) -> Dict[str, str]:
     return output_columns_to_hashes
 
 
-def get_pre_derived_group_by_features(group_by: GroupBy, additional_semantic_fields=None) -> Dict[str, str]:
+def get_pre_derived_group_by_features(
+    group_by: GroupBy, additional_semantic_fields=None
+) -> Dict[str, str]:
     # Get the base semantic fields that apply to all aggs
     if additional_semantic_fields is None:
         additional_semantic_fields = []
@@ -174,9 +184,13 @@ def get_pre_derived_group_by_features(group_by: GroupBy, additional_semantic_fie
     # For group_bys with aggregations, aggregated columns
     if group_by.aggregations:
         for agg in group_by.aggregations:
-            input_expression_str = ",".join(get_input_expression_across_sources(group_by, agg.inputColumn))
+            input_expression_str = ",".join(
+                get_input_expression_across_sources(group_by, agg.inputColumn)
+            )
             for output_col_name in get_output_col_names(agg):
-                output_columns[output_col_name] = _compute_semantic_hash(base_semantics + [input_expression_str] + additional_semantic_fields)
+                output_columns[output_col_name] = _compute_semantic_hash(
+                    base_semantics + [input_expression_str] + additional_semantic_fields
+                )
     # For group_bys without aggregations, selected fields from query
     else:
         combined_selects = defaultdict(set)
@@ -190,7 +204,10 @@ def get_pre_derived_group_by_features(group_by: GroupBy, additional_semantic_fie
         unified_selects = {key: ",".join(sorted(vals)) for key, vals in combined_selects.items()}
 
         # now compute the hashes on base semantics + expression
-        selected_hashes = {key: _compute_semantic_hash(base_semantics + [val] + additional_semantic_fields) for key, val in unified_selects.items()}
+        selected_hashes = {
+            key: _compute_semantic_hash(base_semantics + [val] + additional_semantic_fields)
+            for key, val in unified_selects.items()
+        }
         output_columns.update(selected_hashes)
     return output_columns
 
@@ -262,11 +279,13 @@ def _compute_semantic_hash(components: List[str]) -> str:
     # Sort components to ensure consistent ordering
     sorted_components = sorted(components)
     hash_input = "|".join(sorted_components)
-    return hashlib.md5(hash_input.encode('utf-8')).hexdigest()
+    return hashlib.md5(hash_input.encode("utf-8")).hexdigest()
 
 
 def build_derived_columns(
-    base_columns_to_hashes: Dict[str, str], derivations: List[Derivation], additional_semantic_fields: List[str]
+    base_columns_to_hashes: Dict[str, str],
+    derivations: List[Derivation],
+    additional_semantic_fields: List[str],
 ) -> Dict[str, str]:
     """
     Build the derived columns from pre-derived columns and derivations.
@@ -279,20 +298,24 @@ def build_derived_columns(
             output_columns.update(base_columns_to_hashes)
         for derivation in derivations:
             if base_columns_to_hashes.get(derivation.expression):
-               # don't change the semantics if you're just passing a base column through derivations
-               output_columns[derivation.name] = base_columns_to_hashes[derivation.expression]
+                # don't change the semantics if you're just passing a base column through derivations
+                output_columns[derivation.name] = base_columns_to_hashes[derivation.expression]
             if derivation.name != "*":
                 # Identify base fields present within the derivation to include in the semantic hash
                 # We go long to short to avoid taking both a windowed feature and the unwindowed feature
                 # i.e. f_7d and f
                 derivation_expression = derivation.expression
                 base_col_semantic_fields = []
-                tokens = re.findall(r'\b\w+\b', derivation_expression)
+                tokens = re.findall(r"\b\w+\b", derivation_expression)
                 for token in tokens:
                     if token in base_columns_to_hashes:
                         base_col_semantic_fields.append(base_columns_to_hashes[token])
 
-                output_columns[derivation.name] = _compute_semantic_hash(additional_semantic_fields + [f"derivation:{derivation.expression}"] + base_col_semantic_fields)
+                output_columns[derivation.name] = _compute_semantic_hash(
+                    additional_semantic_fields
+                    + [f"derivation:{derivation.expression}"]
+                    + base_col_semantic_fields
+                )
     return output_columns
 
 

ai/chronon/cli/compile/compile_context.py

@@ -2,14 +2,14 @@ import os
 from dataclasses import dataclass
 from typing import Any, Dict, List, Optional, Type
 
+from gen_thrift.api.ttypes import ConfType, GroupBy, Join, MetaData, Model, StagingQuery, Team
+
 import ai.chronon.cli.compile.parse_teams as teams
-from ai.chronon.api.ttypes import GroupBy, Join, MetaData, Model, StagingQuery, Team
 from ai.chronon.cli.compile.conf_validator import ConfValidator
 from ai.chronon.cli.compile.display.compile_status import CompileStatus
 from ai.chronon.cli.compile.display.compiled_obj import CompiledObj
 from ai.chronon.cli.compile.serializer import file2thrift
 from ai.chronon.cli.logger import get_logger, require
-from ai.chronon.orchestration.ttypes import ConfType
 
 logger = get_logger()
 
@@ -23,11 +23,11 @@ class ConfigInfo:
 
 @dataclass
 class CompileContext:
-
-    def __init__(self):
+    def __init__(self, ignore_python_errors: bool = False):
         self.chronon_root: str = os.getenv("CHRONON_ROOT", os.getcwd())
         self.teams_dict: Dict[str, Team] = teams.load_teams(self.chronon_root)
         self.compile_dir: str = "compiled"
+        self.ignore_python_errors: bool = ignore_python_errors
 
         self.config_infos: List[ConfigInfo] = [
             ConfigInfo(folder_name="joins", cls=Join, config_type=ConfType.JOIN),
@@ -42,7 +42,9 @@ class CompileContext:
                 config_type=ConfType.STAGING_QUERY,
             ),
             ConfigInfo(folder_name="models", cls=Model, config_type=ConfType.MODEL),
-            ConfigInfo(folder_name="teams_metadata", cls=MetaData, config_type=None), # only for team metadata
+            ConfigInfo(
+                folder_name="teams_metadata", cls=MetaData, config_type=None
+            ),  # only for team metadata
         ]
 
         self.compile_status = CompileStatus(use_live=False)
@@ -52,13 +54,12 @@ class CompileContext:
             cls = config_info.cls
             self.existing_confs[cls] = self._parse_existing_confs(cls)
 
-
-
         self.validator: ConfValidator = ConfValidator(
             input_root=self.chronon_root,
             output_root=self.compile_dir,
             existing_gbs=self.existing_confs[GroupBy],
             existing_joins=self.existing_confs[Join],
+            existing_staging_queries=self.existing_confs[StagingQuery],
         )
 
     def input_dir(self, cls: type) -> str:
@@ -93,9 +94,7 @@ class CompileContext:
             return os.path.join(self.chronon_root, self.compile_dir)
         else:
             config_info = self.config_info_for_class(cls)
-            return os.path.join(
-                self.chronon_root, self.compile_dir, config_info.folder_name
-            )
+            return os.path.join(self.chronon_root, self.compile_dir, config_info.folder_name)
 
     def staging_output_path(self, compiled_obj: CompiledObj):
         """
@@ -121,7 +120,6 @@ class CompileContext:
         require(False, f"Class {cls} not found in CONFIG_INFOS")
 
     def _parse_existing_confs(self, obj_class: type) -> Dict[str, object]:
-
         result = {}
 
         output_dir = self.output_dir(obj_class)
@@ -131,9 +129,7 @@ class CompileContext:
             return result
 
         for sub_root, _sub_dirs, sub_files in os.walk(output_dir):
-
             for f in sub_files:
-
                 if f.startswith("."):  # ignore hidden files - such as .DS_Store
                     continue
 
@@ -155,7 +151,9 @@ class CompileContext:
                             )
                             self.compile_status.add_existing_object_update_display(compiled_obj)
                         elif isinstance(obj, MetaData):
-                            team_metadata_name = '.'.join(full_path.split('/')[-2:]) # use the name of the file as team metadata won't have name
+                            team_metadata_name = ".".join(
+                                full_path.split("/")[-2:]
+                            )  # use the name of the file as team metadata won't have name
                             result[team_metadata_name] = obj
                             compiled_obj = CompiledObj(
                                 name=team_metadata_name,
@@ -167,9 +165,7 @@ class CompileContext:
                             )
                             self.compile_status.add_existing_object_update_display(compiled_obj)
                     else:
-                        logger.errors(
-                            f"Parsed object from {full_path} has no metaData attribute"
-                        )
+                        logger.errors(f"Parsed object from {full_path} has no metaData attribute")
 
                 except Exception as e:
                     print(f"Failed to parse file {full_path}: {str(e)}", e)

ai/chronon/cli/compile/compiler.py

@@ -4,6 +4,8 @@ import traceback
 from dataclasses import dataclass
 from typing import Any, Dict, List, Optional, Tuple
 
+from gen_thrift.api.ttypes import ConfType
+
 import ai.chronon.cli.compile.display.compiled_obj
 import ai.chronon.cli.compile.parse_configs as parser
 import ai.chronon.cli.logger as logger
@@ -12,7 +14,6 @@ from ai.chronon.cli.compile.compile_context import CompileContext, ConfigInfo
 from ai.chronon.cli.compile.display.compiled_obj import CompiledObj
 from ai.chronon.cli.compile.display.console import console
 from ai.chronon.cli.compile.parse_teams import merge_team_execution_info
-from ai.chronon.orchestration.ttypes import ConfType
 from ai.chronon.types import MetaData
 
 logger = logger.get_logger()
@@ -26,42 +27,72 @@ class CompileResult:
 
 
 class Compiler:
-
     def __init__(self, compile_context: CompileContext):
         self.compile_context = compile_context
 
     def compile(self) -> Dict[ConfType, CompileResult]:
+        # Clean staging directory at the start to ensure fresh compilation
+        staging_dir = self.compile_context.staging_output_dir()
+        if os.path.exists(staging_dir):
+            shutil.rmtree(staging_dir)
 
         config_infos = self.compile_context.config_infos
 
         compile_results = {}
+        all_compiled_objects = []  # Collect all compiled objects for change validation
 
         for config_info in config_infos:
-            configs = self._compile_class_configs(config_info)
-
+            configs, compiled_objects = self._compile_class_configs(config_info)
             compile_results[config_info.config_type] = configs
-        self._compile_team_metadata()
 
-        # check if staging_output_dir exists
-        staging_dir = self.compile_context.staging_output_dir()
-        if os.path.exists(staging_dir):
-            # replace staging_output_dir to output_dir
-            output_dir = self.compile_context.output_dir()
-            if os.path.exists(output_dir):
-                shutil.rmtree(output_dir)
-            shutil.move(staging_dir, output_dir)
-        else:
-            print(
-                f"Staging directory {staging_dir} does not exist. "
-                "Happens when every chronon config fails to compile or when no chronon configs exist."
-            )
+            # Collect compiled objects for change validation
+            all_compiled_objects.extend(compiled_objects)
+
+        # Validate changes once after all classes have been processed
+        self.compile_context.validator.validate_changes(all_compiled_objects)
 
-        # TODO: temporarily just print out the final results of the compile until live fix is implemented:
-        #  https://github.com/Textualize/rich/pull/3637
-        console.print(self.compile_context.compile_status.render())
+        # Show the nice display first
+        console.print(
+            self.compile_context.compile_status.render(self.compile_context.ignore_python_errors)
+        )
+
+        # Check for confirmation before finalizing files
+        self.compile_context.validator.check_pending_changes_confirmation(
+            self.compile_context.compile_status
+        )
+
+        # Only proceed with file operations if there are no compilation errors
+        if not self._has_compilation_errors() or self.compile_context.ignore_python_errors:
+            self._compile_team_metadata()
+
+            # check if staging_output_dir exists
+            staging_dir = self.compile_context.staging_output_dir()
+            if os.path.exists(staging_dir):
+                # replace staging_output_dir to output_dir
+                output_dir = self.compile_context.output_dir()
+                if os.path.exists(output_dir):
+                    shutil.rmtree(output_dir)
+                shutil.move(staging_dir, output_dir)
+            else:
+                print(
+                    f"Staging directory {staging_dir} does not exist. "
+                    "Happens when every chronon config fails to compile or when no chronon configs exist."
+                )
+        else:
+            # Clean up staging directory when there are errors (don't move to output)
+            staging_dir = self.compile_context.staging_output_dir()
+            if os.path.exists(staging_dir):
+                shutil.rmtree(staging_dir)
 
         return compile_results
 
+    def _has_compilation_errors(self):
+        """Check if there are any compilation errors across all class trackers."""
+        for tracker in self.compile_context.compile_status.cls_to_tracker.values():
+            if tracker.files_to_errors:
+                return True
+        return False
+
     def _compile_team_metadata(self):
         """
         Compile the team metadata and return the compiled object.
@@ -87,17 +118,14 @@ class Compiler:
         # Done writing team metadata, close the class
         self.compile_context.compile_status.close_cls(MetaData.__name__)
 
-    def _compile_class_configs(self, config_info: ConfigInfo) -> CompileResult:
-
-        compile_result = CompileResult(
-            config_info=config_info, obj_dict={}, error_dict={}
-        )
+    def _compile_class_configs(
+        self, config_info: ConfigInfo
+    ) -> Tuple[CompileResult, List[CompiledObj]]:
+        compile_result = CompileResult(config_info=config_info, obj_dict={}, error_dict={})
 
         input_dir = self.compile_context.input_dir(config_info.cls)
 
-        compiled_objects = parser.from_folder(
-            config_info.cls, input_dir, self.compile_context
-        )
+        compiled_objects = parser.from_folder(config_info.cls, input_dir, self.compile_context)
 
         objects, errors = self._write_objects_in_folder(compiled_objects)
 
@@ -109,20 +137,17 @@ class Compiler:
 
         self.compile_context.compile_status.close_cls(config_info.cls.__name__)
 
-        return compile_result
+        return compile_result, compiled_objects
 
     def _write_objects_in_folder(
         self,
         compiled_objects: List[ai.chronon.cli.compile.display.compiled_obj.CompiledObj],
     ) -> Tuple[Dict[str, Any], Dict[str, List[BaseException]]]:
-
         error_dict = {}
         object_dict = {}
 
         for co in compiled_objects:
-
             if co.obj:
-
                 if co.errors:
                     error_dict[co.name] = co.errors
 
@@ -130,9 +155,7 @@ class Compiler:
                         self.compile_context.compile_status.print_live_console(
                             f"Error processing conf {co.name}: {error}"
                         )
-                        traceback.print_exception(
-                            type(error), error, error.__traceback__
-                        )
+                        traceback.print_exception(type(error), error, error.__traceback__)
 
                 else:
                     self._write_object(co)