awx-zipline-ai 0.2.1__py3-none-any.whl → 0.3.1__py3-none-any.whl

ai/chronon/cli/compile/conf_validator.py

@@ -1,5 +1,4 @@
-"""Object for checking whether a Chronon API thrift object is consistent with other
-"""
+"""Object for checking whether a Chronon API thrift object is consistent with other"""
 
 #     Copyright (C) 2023 The Chronon Authors.
 #
@@ -18,12 +17,14 @@
 import json
 import logging
 import re
+import sys
 import textwrap
 from collections import defaultdict
+from dataclasses import dataclass
 from typing import Dict, List, Tuple
 
-import ai.chronon.api.common.ttypes as common
-from ai.chronon.api.ttypes import (
+import gen_thrift.common.ttypes as common
+from gen_thrift.api.ttypes import (
     Accuracy,
     Aggregation,
     Derivation,
@@ -33,6 +34,7 @@ from ai.chronon.api.ttypes import (
     JoinPart,
     Source,
 )
+
 from ai.chronon.cli.compile.column_hashing import (
     compute_group_by_columns_hashes,
     get_pre_derived_group_by_columns,
@@ -40,6 +42,7 @@ from ai.chronon.cli.compile.column_hashing import (
     get_pre_derived_join_features,
     get_pre_derived_source_keys,
 )
+from ai.chronon.cli.compile.version_utils import is_version_change
 from ai.chronon.logger import get_logger
 from ai.chronon.repo.serializer import thrift_simple_json
 from ai.chronon.utils import get_query, get_root_source
@@ -49,6 +52,20 @@ SKIPPED_FIELDS = frozenset(["metaData"])
 EXTERNAL_KEY = "onlineExternalParts"
 
 
+@dataclass
+class ConfigChange:
+    """Represents a change to a compiled config object."""
+
+    name: str
+    obj_type: str
+    online: bool = False
+    production: bool = False
+    base_name: str = None
+    old_version: int = None
+    new_version: int = None
+    is_version_change: bool = False
+
+
 def _filter_skipped_fields_from_join(json_obj: Dict, skipped_fields):
     for join_part in json_obj["joinParts"]:
         group_by = join_part["groupBy"]
@@ -91,7 +108,6 @@ def _group_by_has_hourly_windows(groupBy: GroupBy) -> bool:
         return False
 
     for agg in aggs:
-
         if not agg.windows:
             return False
 
@@ -103,9 +119,7 @@ def _group_by_has_hourly_windows(groupBy: GroupBy) -> bool:
 
 
 def detect_feature_name_collisions(
-        group_bys: List[Tuple[GroupBy, str]],
-        entity_set_type: str,
-        name: str
+    group_bys: List[Tuple[GroupBy, str]], entity_set_type: str, name: str
 ) -> BaseException | None:
     # Build a map of output_column -> set of group_by name
     output_col_to_gbs = {}
@@ -115,7 +129,7 @@ def detect_feature_name_collisions(
         prefix_str = jp_prefix_str + key_str + "_"
         cols = compute_group_by_columns_hashes(gb, exclude_keys=True)
         if not cols:
-            print('HERE')
+            print("HERE")
         cols = {
             f"{prefix_str}{base_col}"
             for base_col in list(compute_group_by_columns_hashes(gb, exclude_keys=True).keys())
@@ -127,19 +141,13 @@ def detect_feature_name_collisions(
             output_col_to_gbs[col].add(gb_name)
 
     # Find output columns that are produced by more than one group_by
-    collisions = {
-        col: gb_names
-        for col, gb_names in output_col_to_gbs.items()
-        if len(gb_names) > 1
-    }
+    collisions = {col: gb_names for col, gb_names in output_col_to_gbs.items() if len(gb_names) > 1}
 
     if not collisions:
         return None  # no collisions
 
     # Assemble an error message listing the conflicting GroupBys by name
-    lines = [
-        f"{entity_set_type} for Join: {name} has the following output name collisions:\n"
-    ]
+    lines = [f"{entity_set_type} for Join: {name} has the following output name collisions:\n"]
     for col, gb_names in collisions.items():
         names_str = ", ".join(sorted(gb_names))
         lines.append(f"  - [{col}] has collisions from: [{names_str}]")
@@ -161,9 +169,9 @@ class ConfValidator(object):
         output_root,
         existing_gbs,
         existing_joins,
+        existing_staging_queries,
         log_level=logging.INFO,
     ):
-
         self.chronon_root_path = input_root
         self.output_root = output_root
 
@@ -176,8 +184,10 @@ class ConfValidator(object):
         self.old_objs = defaultdict(dict)
         self.old_group_bys = existing_gbs
         self.old_joins = existing_joins
+        self.old_staging_queries = existing_staging_queries
         self.old_objs["GroupBy"] = self.old_group_bys
         self.old_objs["Join"] = self.old_joins
+        self.old_objs["StagingQuery"] = self.old_staging_queries
 
     def _get_old_obj(self, obj_class: type, obj_name: str) -> object:
         """
@@ -223,9 +233,7 @@ class ConfValidator(object):
             elif not any(
                 join.metaData.online for join in self._get_old_joins_with_group_by(obj)
             ) and not _is_batch_upload_needed(obj):
-                reasons.append(
-                    "is not marked online/production nor is included in any online join"
-                )
+                reasons.append("is not marked online/production nor is included in any online join")
         return reasons
 
     def validate_obj(self, obj: object) -> List[BaseException]:
@@ -241,13 +249,9 @@ class ConfValidator(object):
             return self._validate_join(obj)
         return []
 
-    def _has_diff(
-        self, obj: object, old_obj: object, skipped_fields=SKIPPED_FIELDS
-    ) -> bool:
+    def _has_diff(self, obj: object, old_obj: object, skipped_fields=SKIPPED_FIELDS) -> bool:
         new_json = {
-            k: v
-            for k, v in json.loads(thrift_simple_json(obj)).items()
-            if k not in skipped_fields
+            k: v for k, v in json.loads(thrift_simple_json(obj)).items() if k not in skipped_fields
         }
         old_json = {
             k: v
@@ -257,6 +261,7 @@ class ConfValidator(object):
         if isinstance(obj, Join):
             _filter_skipped_fields_from_join(new_json, skipped_fields)
             _filter_skipped_fields_from_join(old_json, skipped_fields)
+
         return new_json != old_json
 
     def safe_to_overwrite(self, obj: object) -> bool:
@@ -264,11 +269,7 @@ class ConfValidator(object):
         to materialize and overwrite the old conf.
         """
         old_obj = self._get_old_obj(type(obj), obj.metaData.name)
-        return (
-            not old_obj
-            or not self._has_diff(obj, old_obj)
-            or not old_obj.metaData.online
-        )
+        return not old_obj or not self._has_diff(obj, old_obj) or not old_obj.metaData.online
 
     def _validate_derivations(
         self, pre_derived_cols: List[str], derivations: List[Derivation]
@@ -295,23 +296,26 @@ class ConfValidator(object):
                 if wild_card_derivation_included:
                     if derivation.expression in derived_columns:
                         derived_columns.remove(derivation.expression)
-                if (
-                    derivation.expression not in pre_derived_cols
-                    and derivation.expression not in ("ds", "ts")
+                if derivation.expression not in pre_derived_cols and derivation.expression not in (
+                    "ds",
+                    "ts",
                 ):
                     errors.append(
-                        ValueError("Incorrect derivation expression {}, expression not found in pre-derived columns {}"
-                        .format(
-                            derivation.expression, pre_derived_cols
-                        ))
+                        ValueError(
+                            "Incorrect derivation expression {}, expression not found in pre-derived columns {}".format(
+                                derivation.expression, pre_derived_cols
+                            )
+                        )
                     )
             if derivation.name != "*":
                 if derivation.name in derived_columns:
                     errors.append(
-                        ValueError("Incorrect derivation name {} due to output column name conflict".format(
-                            derivation.name
+                        ValueError(
+                            "Incorrect derivation name {} due to output column name conflict".format(
+                                derivation.name
+                            )
                         )
-                    ))
+                    )
                 else:
                     derived_columns.add(derivation.name)
         return errors
@@ -344,17 +348,20 @@ class ConfValidator(object):
                 err_string += f"\n- The following keys in your key_mapping: {str(key_map_keys_missing_from_left)} for JoinPart {group_by_name} are not included in the left side of the join: {left_cols_as_str}"
 
             # Right side of key mapping should only include keys in GroupBy
-            keys_missing_from_key_map_values = [v for v in key_mapping.values() if v not in join_part.groupBy.keyColumns]
+            keys_missing_from_key_map_values = [
+                v for v in key_mapping.values() if v not in join_part.groupBy.keyColumns
+            ]
             if keys_missing_from_key_map_values:
                 err_string += f"\n- The following values in your key_mapping: {str(keys_missing_from_key_map_values)}  for JoinPart {group_by_name} do not cover any group by key columns: {join_part.groupBy.keyColumns}"
 
             if key_map_keys_missing_from_left or keys_missing_from_key_map_values:
-                err_string += "\n(Key Mapping should be formatted as column_from_left -> group_by_key)"
+                err_string += (
+                    "\n(Key Mapping should be formatted as column_from_left -> group_by_key)"
+                )
 
         if err_string:
             return ValueError(err_string)
 
-
     def _validate_keys(self, join: Join) -> List[BaseException]:
         left = join.left
 
@@ -375,7 +382,7 @@ class ConfValidator(object):
         errors = []
 
         if left_cols:
-            join_parts = join.joinParts
+            join_parts = list(join.joinParts)  # Create a copy to avoid modifying the original
 
             # Add label_parts to join_parts to validate if set
             label_parts = join.labelParts
@@ -391,7 +398,6 @@ class ConfValidator(object):
 
         return errors
 
-
     def _validate_join(self, join: Join) -> List[BaseException]:
         """
         Validate join's status with materialized versions of group_bys
@@ -402,7 +408,9 @@ class ConfValidator(object):
         """
         included_group_bys_and_prefixes = [(rp.groupBy, rp.prefix) for rp in join.joinParts]
         # TODO: Remove label parts check in future PR that deprecates label_parts
-        included_label_parts_and_prefixes = [(lp.groupBy, lp.prefix) for lp in join.labelParts.labels] if join.labelParts else []
+        included_label_parts_and_prefixes = (
+            [(lp.groupBy, lp.prefix) for lp in join.labelParts.labels] if join.labelParts else []
+        )
         included_group_bys = [tup[0] for tup in included_group_bys_and_prefixes]
 
         offline_included_group_bys = [
@@ -422,9 +430,7 @@ class ConfValidator(object):
             if group_by.metaData.production is False
         ]
         # Check if the underlying groupBy is valid
-        group_by_errors = [
-            self._validate_group_by(group_by) for group_by in included_group_bys
-        ]
+        group_by_errors = [self._validate_group_by(group_by) for group_by in included_group_bys]
         errors += [
             ValueError(f"join {join.metaData.name}'s underlying {error}")
             for errors in group_by_errors
@@ -433,18 +439,22 @@ class ConfValidator(object):
         # Check if the production join is using non production groupBy
         if join.metaData.production and non_prod_old_group_bys:
             errors.append(
-                ValueError("join {} is production but includes the following non production group_bys: {}".format(
-                    join.metaData.name, ", ".join(non_prod_old_group_bys)
+                ValueError(
+                    "join {} is production but includes the following non production group_bys: {}".format(
+                        join.metaData.name, ", ".join(non_prod_old_group_bys)
+                    )
                 )
-            ))
+            )
         # Check if the online join is using the offline groupBy
         if join.metaData.online:
             if offline_included_group_bys:
                 errors.append(
-                    ValueError("join {} is online but includes the following offline group_bys: {}".format(
-                        join.metaData.name, ", ".join(offline_included_group_bys)
+                    ValueError(
+                        "join {} is online but includes the following offline group_bys: {}".format(
+                            join.metaData.name, ", ".join(offline_included_group_bys)
+                        )
                     )
-                ))
+                )
         # Only validate the join derivation when the underlying groupBy is valid
         group_by_correct = all(not errors for errors in group_by_errors)
         if join.derivations and group_by_correct:
@@ -457,22 +467,23 @@ class ConfValidator(object):
                 columns = features + keys
             errors.extend(self._validate_derivations(columns, join.derivations))
 
-
         errors.extend(self._validate_keys(join))
 
         # If the join is using "short" names, ensure that there are no collisions
         if join.useLongNames is False:
-            right_part_collisions = detect_feature_name_collisions(included_group_bys_and_prefixes, "right parts", join.metaData.name)
+            right_part_collisions = detect_feature_name_collisions(
+                included_group_bys_and_prefixes, "right parts", join.metaData.name
+            )
             if right_part_collisions:
                 errors.append(right_part_collisions)
 
-            label_part_collisions = detect_feature_name_collisions(included_label_parts_and_prefixes, "label parts", join.metaData.name)
+            label_part_collisions = detect_feature_name_collisions(
+                included_label_parts_and_prefixes, "label parts", join.metaData.name
+            )
             if label_part_collisions:
                 errors.append(label_part_collisions)
 
         return errors
-    
-
 
     def _validate_group_by(self, group_by: GroupBy) -> List[BaseException]:
         """
@@ -483,17 +494,11 @@ class ConfValidator(object):
           List of validation errors.
         """
         joins = self._get_old_joins_with_group_by(group_by)
-        online_joins = [
-            join.metaData.name for join in joins if join.metaData.online is True
-        ]
-        prod_joins = [
-            join.metaData.name for join in joins if join.metaData.production is True
-        ]
+        online_joins = [join.metaData.name for join in joins if join.metaData.online is True]
+        prod_joins = [join.metaData.name for join in joins if join.metaData.production is True]
         errors = []
 
-        non_temporal = (
-            group_by.accuracy is None or group_by.accuracy == Accuracy.SNAPSHOT
-        )
+        non_temporal = group_by.accuracy is None or group_by.accuracy == Accuracy.SNAPSHOT
 
         no_topic = not _group_by_has_topic(group_by)
         has_hourly_windows = _group_by_has_hourly_windows(group_by)
@@ -501,48 +506,55 @@ class ConfValidator(object):
         # batch features cannot contain hourly windows
         if (no_topic and non_temporal) and has_hourly_windows:
             errors.append(
-                ValueError(f"group_by {group_by.metaData.name} is defined to be daily refreshed but contains "
-                           f"hourly windows. "
-                           )
+                ValueError(
+                    f"group_by {group_by.metaData.name} is defined to be daily refreshed but contains "
+                    f"hourly windows. "
+                )
             )
 
         def _validate_bounded_event_source():
             if group_by.aggregations is None:
                 return
-            
+
             unbounded_event_sources = [
                 str(src)
-                for src in group_by.sources 
-                if isinstance(get_root_source(src), EventSource) and get_query(src).startPartition is None
+                for src in group_by.sources
+                if isinstance(get_root_source(src), EventSource)
+                and get_query(src).startPartition is None
             ]
 
             if not unbounded_event_sources:
                 return
-            
-            unwindowed_aggregations = [str(agg) for agg in group_by.aggregations if agg.windows is None]
+
+            unwindowed_aggregations = [
+                str(agg) for agg in group_by.aggregations if agg.windows is None
+            ]
 
             if not unwindowed_aggregations:
                 return
-            
+
             nln = "\n"
 
             errors.append(
                 ValueError(
                     f"""group_by {group_by.metaData.name} uses unwindowed aggregations [{nln}{f",{nln}".join(unwindowed_aggregations)}{nln}] 
                     on unbounded event sources: [{nln}{f",{nln}".join(unbounded_event_sources)}{nln}]. 
-                    Please set a start_partition on the source, or a window on the aggregation.""")
+                    Please set a start_partition on the source, or a window on the aggregation."""
                 )
-            
+            )
+
         _validate_bounded_event_source()
 
         # group by that are marked explicitly offline should not be present in
         # materialized online joins.
         if group_by.metaData.online is False and online_joins:
             errors.append(
-                ValueError("group_by {} is explicitly marked offline but included in "
-                "the following online joins: {}".format(
-                    group_by.metaData.name, ", ".join(online_joins)
-                ))
+                ValueError(
+                    "group_by {} is explicitly marked offline but included in "
+                    "the following online joins: {}".format(
+                        group_by.metaData.name, ", ".join(online_joins)
+                    )
+                )
             )
         # group by that are marked explicitly non-production should not be
         # present in materialized production joins.
@@ -551,8 +563,9 @@ class ConfValidator(object):
                 errors.append(
                     ValueError(
                         "group_by {} is explicitly marked as non-production but included in the following production "
-                    "joins: {}".format(group_by.metaData.name, ", ".join(prod_joins))
-                ))
+                        "joins: {}".format(group_by.metaData.name, ", ".join(prod_joins))
+                    )
+                )
             # if the group by is included in any of materialized production join,
             # set it to production in the materialized output.
             else:
@@ -569,22 +582,161 @@ class ConfValidator(object):
 
         for source in group_by.sources:
             src: Source = source
-            if (
-                src.events
-                and src.events.isCumulative
-                and (src.events.query.timeColumn is None)
-            ):
+            if src.events and src.events.isCumulative and (src.events.query.timeColumn is None):
                 errors.append(
-                    ValueError("Please set query.timeColumn for Cumulative Events Table: {}".format(
-                        src.events.table
-                    ))
+                    ValueError(
+                        "Please set query.timeColumn for Cumulative Events Table: {}".format(
+                            src.events.table
+                        )
+                    )
                 )
-            elif (
-                src.joinSource
-            ):
+            elif src.joinSource:
                 join_obj = src.joinSource.join
                 if join_obj.metaData.name is None or join_obj.metaData.team is None:
                     errors.append(
                         ValueError(f"Join must be defined with team and name: {join_obj}")
                     )
         return errors
+
+    def validate_changes(self, results):
+        """
+        Validate changes in compiled objects against existing materialized objects.
+
+        Args:
+            results: List of CompiledObj from parse_configs
+
+        Returns:
+            None (exits on user cancellation)
+        """
+
+        # Filter out results with errors and only process GroupBy/Join
+        valid_results = []
+        for result in results:
+            if result.errors:
+                continue  # Skip results with errors
+            if result.obj_type not in ["GroupBy", "Join", "StagingQuery"]:
+                continue  # Skip non-GroupBy/Join objects
+            valid_results.append(result)
+
+        # Categorize changes
+        changed_objects = {"changed": [], "deleted": [], "added": []}
+
+        # Process each valid result
+        for result in valid_results:
+            obj_name = result.obj.metaData.name
+            obj_type = result.obj_type
+
+            # Check if object exists in old objects
+            old_obj = self._get_old_obj(type(result.obj), obj_name)
+
+            if old_obj is None:
+                # New object
+                change = self._create_config_change(result.obj, obj_type)
+                changed_objects["added"].append(change)
+            elif self._has_diff(result.obj, old_obj):
+                # Modified object
+                change = self._create_config_change(result.obj, obj_type)
+                changed_objects["changed"].append(change)
+
+        # Check for deleted objects
+        # Build set of current objects from valid_results for lookup
+        current_objects = {(result.obj_type, result.obj.metaData.name) for result in valid_results}
+
+        for obj_type in ["GroupBy", "Join", "StagingQuery"]:
+            old_objs = self.old_objs.get(obj_type, {})
+            for obj_name, old_obj in old_objs.items():
+                if (obj_type, obj_name) not in current_objects:
+                    # Object was deleted
+                    change = self._create_config_change(old_obj, obj_type)
+                    changed_objects["deleted"].append(change)
+
+        # Store changes for later confirmation check
+        self._pending_changes = {
+            "changed": changed_objects["changed"],
+            "deleted": changed_objects["deleted"],
+            "added": changed_objects["added"],
+        }
+
+    def _filter_non_version_changes(self, existing_changes, added_changes):
+        """Filter out version changes from existing changes.
+
+        Returns list of changes that are NOT version bumps and require confirmation.
+        """
+        added_names = {change.name for change in added_changes}
+        non_version_changes = []
+
+        for change in existing_changes:
+            # Check if this deleted config has a corresponding added config that represents a version bump
+            is_version_bump = any(
+                is_version_change(change.name, added_name) for added_name in added_names
+            )
+
+            if not is_version_bump:
+                non_version_changes.append(change)
+
+        return non_version_changes
+
+    def check_pending_changes_confirmation(self, compile_status):
+        """Check if user confirmation is needed for pending changes after display."""
+        from ai.chronon.cli.compile.display.console import console
+
+        # Skip confirmation if there are compilation errors
+        if self._has_compilation_errors(compile_status):
+            return  # Don't prompt when there are errors
+
+        if not hasattr(self, "_pending_changes"):
+            return  # No pending changes
+
+        # Check if we need user confirmation (only for non-version-bump changes)
+        non_version_changes = self._filter_non_version_changes(
+            self._pending_changes["changed"] + self._pending_changes["deleted"],
+            self._pending_changes["added"],
+        )
+
+        if non_version_changes:
+            if not self._prompt_user_confirmation():
+                console.print("❌ Compilation cancelled by user.")
+                sys.exit(1)
+
+    def _has_compilation_errors(self, compile_status):
+        """Check if there are any compilation errors across all class trackers."""
+        for tracker in compile_status.cls_to_tracker.values():
+            if tracker.files_to_errors:
+                return True
+        return False
+
+    def _create_config_change(self, obj, obj_type):
+        """Create a ConfigChange object from a thrift object."""
+        return ConfigChange(
+            name=obj.metaData.name,
+            obj_type=obj_type,
+            online=obj.metaData.online if obj.metaData.online else False,
+            production=obj.metaData.production if obj.metaData.production else False,
+        )
+
+    def _prompt_user_confirmation(self) -> bool:
+        """
+        Prompt user for Y/N confirmation to proceed with overwriting existing configs.
+        Returns True if user confirms, False otherwise.
+        """
+        from ai.chronon.cli.compile.display.console import console
+
+        console.print(
+            "\n❗ [bold red3]Some configs are changing in-place (changing semantics without changing the version).[/bold red3]"
+        )
+        console.print(
+            "[dim]Note that changes can be caused by directly modifying a config, or by changing the version of an upstream object which changes the input source.[/dim]"
+        )
+        console.print("")
+        console.print(
+            "[dim]This can be a safe operation if you are sure that the configs that are unaffected by the change (i.e. upstream config is versioning up in a way that does not effect the downstream), or if the objects in question are not yet used by critical workloads.[/dim]"
+        )
+        console.print("")
+        console.print("❓ [bold]Do you want to proceed? (y/N):[/bold]", end=" ")
+
+        try:
+            response = input().strip().lower()
+            return response in ["y", "yes"]
+        except (EOFError, KeyboardInterrupt):
+            console.print("\n❌ Compilation cancelled.")
+            return False

ai/chronon/cli/compile/display/class_tracker.py

@@ -24,9 +24,7 @@ class ClassTracker:
         self.existing_objs[obj.name] = obj
 
     def add(self, compiled: CompiledObj) -> None:
-
         if compiled.errors:
-
             if compiled.file not in self.files_to_errors:
                 self.files_to_errors[compiled.file] = []
 
@@ -43,12 +41,10 @@ class ClassTracker:
 
     def _update_diff(self, compiled: CompiledObj) -> None:
         if compiled.name in self.existing_objs:
-
             existing_json = self.existing_objs[compiled.name].tjson
             new_json = compiled.tjson
 
             if existing_json != new_json:
-
                 diff = difflib.unified_diff(
                     existing_json.splitlines(keepends=True),
                     new_json.splitlines(keepends=True),
@@ -74,16 +70,7 @@ class ClassTracker:
         text = Text(overflow="fold", no_wrap=False)
 
         if self.existing_objs:
-            text.append(
-                f"  Parsed {len(self.existing_objs)} previously compiled objects.\n"
-            )
-
-        if self.files_to_obj:
-            text.append("  Compiled ")
-            text.append(f"{len(self.new_objs)} ", style="bold green")
-            text.append("objects from ")
-            text.append(f"{len(self.files_to_obj)} ", style="bold green")
-            text.append("files.\n")
+            text.append(f"  Parsed {len(self.existing_objs)} previously compiled objects.\n")
 
         if self.files_to_errors:
             text.append("  Failed to compile ")
@@ -99,7 +86,7 @@ class ClassTracker:
             for file, errors in self.files_to_errors.items():
                 text.append("  ERROR ", style="bold red")
                 text.append(f"- {file}:\n")
-                
+
                 for error in errors:
                     # Format each error properly, handling newlines
                     error_msg = str(error)
@@ -108,5 +95,8 @@ class ClassTracker:
         return text
 
     # doesn't make sense to show deletes until the very end of compilation
-    def diff(self) -> Text:
+    def diff(self, ignore_python_errors: bool = False) -> Text:
+        # Don't show diff if there are compile errors - it's confusing
+        if self.files_to_errors and not ignore_python_errors:
+            return Text("\n❗Please fix python errors then retry compilation.\n", style="dim cyan")
         return self.diff_result.render(deleted_names=self.deleted_names)