SNOW-2306184: config refactor - remove comments

Author: sfc-gh-mraba

src/snowflake/cli/api/config_ng/parsers.py

@@ -95,19 +95,16 @@ def parse(cls, content: str) -> Dict[str, Any]:
                         section.split(".", 1)[1] if "." in section else "default"
                     )
 
-                # Ensure connections dict exists
                 if "connections" not in result:
                     result["connections"] = {}
                 if conn_name not in result["connections"]:
                     result["connections"][conn_name] = {}
 
-                # Map keys and add to connection
                 for key, value in config[section].items():
                     mapped_key = cls.SNOWSQL_KEY_MAP.get(key, key)
                     result["connections"][conn_name][mapped_key] = value
 
             elif section == "variables":
-                # Process variables section
                 result["variables"] = dict(config[section])
 
         return result

src/snowflake/cli/api/config_ng/presentation.py

@@ -99,11 +99,9 @@ def _should_mask_value(key: str) -> bool:
     """
     key_lower = key.lower()
 
-    # Check if it's a path key (paths are OK to display)
     if any(path_key in key_lower for path_key in PATH_KEYS):
         return False
 
-    # Check if it contains sensitive keywords
     return any(sensitive_key in key_lower for sensitive_key in SENSITIVE_KEYS)
 
 
@@ -168,13 +166,10 @@ def build_sources_table(self, key: Optional[str] = None) -> CollectionResult:
         Args:
             key: Optional specific key to build table for, or None for all keys
         """
-        # Ensure history is populated
         tracker = self._resolver.get_tracker()
         if key is None and not tracker.get_all_histories():
-            # Resolve all keys to populate history
             self._resolver.resolve()
         elif key is not None and tracker.get_history(key) is None:
-            # Resolve only the specific key
             self._resolver.resolve(key=key)
 
         histories = (
@@ -187,21 +182,17 @@ def _row_items():
             for k, history in histories.items():
                 if history is None:
                     continue
-                # Initialize row with fixed columns
                 row: Dict[str, Any] = {c: "" for c in TABLE_COLUMNS}
                 row["key"] = k
 
-                # Final value (masked)
                 masked_final = _mask_sensitive_value(k, history.final_value)
                 row["value"] = masked_final
 
-                # Mark presence per source
                 for entry in history.entries:
                     source_column = SOURCE_TO_COLUMN.get(entry.config_value.source_name)
                     if source_column is not None:
                         row[source_column] = "+"
 
-                # Ensure result preserves the column order
                 ordered_row = {column: row[column] for column in TABLE_COLUMNS}
                 yield ordered_row
 

src/snowflake/cli/api/config_ng/resolution_logger.py

@@ -65,7 +65,6 @@ def get_resolver() -> Optional[ConfigurationResolver]:
     if not isinstance(provider, AlternativeConfigProvider):
         return None
 
-    # Ensure provider is initialized
     provider._ensure_initialized()  # noqa: SLF001
     return provider._resolver  # noqa: SLF001
 
@@ -87,7 +86,6 @@ def show_resolution_chain(key: str) -> None:
 
     provider = get_config_provider_singleton()
 
-    # Force configuration resolution to populate history
     provider.read_config()
 
     resolver = get_resolver()
@@ -114,7 +112,6 @@ def show_all_resolution_chains() -> None:
 
     provider = get_config_provider_singleton()
 
-    # Force configuration resolution to populate history
     provider.read_config()
 
     resolver = get_resolver()
@@ -148,7 +145,6 @@ def get_resolution_summary() -> Optional[Dict]:
 
     provider = get_config_provider_singleton()
 
-    # Force configuration resolution to populate history
     provider.read_config()
 
     resolver = get_resolver()
@@ -179,7 +175,6 @@ def export_resolution_history(output_path: Path) -> bool:
 
     provider = get_config_provider_singleton()
 
-    # Force configuration resolution to populate history
     provider.read_config()
 
     resolver = get_resolver()
@@ -253,7 +248,6 @@ def check_value_source(key: str) -> Optional[str]:
 
     provider = get_config_provider_singleton()
 
-    # Force configuration resolution to populate history
     provider.read_config()
 
     resolver = get_resolver()
@@ -283,7 +277,6 @@ def explain_configuration(key: Optional[str] = None, verbose: bool = False) -> N
 
     provider = get_config_provider_singleton()
 
-    # Force configuration resolution to populate history
     provider.read_config()
 
     resolver = get_resolver()

src/snowflake/cli/api/config_ng/resolver.py

@@ -121,10 +121,8 @@ def record_nested_discovery(
         if not self._enabled:
             return
 
-        # Flatten the nested data
         flat_data = self._flatten_nested_dict(nested_data)
 
-        # Record each flat key
         timestamp = datetime.now()
         for flat_key, value in flat_data.items():
             config_value = ConfigValue(
@@ -157,7 +155,6 @@ def mark_selected(self, key: str, source_name: str) -> None:
         if not self._enabled or key not in self._discoveries:
             return
 
-        # Build resolution history for this key
         entries: List[ResolutionEntry] = []
         selected_value = None
 
@@ -191,12 +188,10 @@ def mark_default_used(self, key: str, default_value: Any) -> None:
         if not self._enabled:
             return
 
-        # Create or update history to indicate default usage
         if key in self._histories:
             self._histories[key].default_used = True
             self._histories[key].final_value = default_value
         else:
-            # No discoveries, only default
             self._histories[key] = ResolutionHistory(
                 key=key, entries=[], final_value=default_value, default_used=True
             )
@@ -235,20 +230,14 @@ def finalize_with_result(self, final_config: Dict[str, Any]) -> None:
         if not self._enabled:
             return
 
-        # Flatten final config to identify which values were selected
         flat_final = self._flatten_nested_dict(final_config)
 
-        # For each flat key in final config, find which source provided it
         for flat_key, final_value in flat_final.items():
-            # Check if this key has discoveries
             if flat_key not in self._discoveries:
                 continue
 
-            # Find the entry with matching value (should be highest priority)
             discoveries = self._discoveries[flat_key]
-            for config_value, timestamp in reversed(
-                discoveries
-            ):  # Check from highest to lowest
+            for config_value, timestamp in reversed(discoveries):
                 if config_value.value == final_value:
                     self.mark_selected(flat_key, config_value.source_name)
                     break
@@ -276,7 +265,6 @@ def record_general_params_merged_to_connections(
 
         timestamp = datetime.now()
         for param_key, param_value in general_params.items():
-            # Record for each connection
             for conn_name in connection_names:
                 flat_key = f"connections.{conn_name}.{param_key}"
                 config_value = ConfigValue(
@@ -301,10 +289,8 @@ def replicate_root_level_discoveries_to_connection(
             return
 
         for param_key in param_keys:
-            # Check if we have discoveries for the root-level key
             if param_key in self._discoveries:
                 conn_key = f"connections.{connection_name}.{param_key}"
-                # Copy all discoveries from root to connection location
                 for config_value, timestamp in self._discoveries[param_key]:
                     self._discoveries[conn_key].append((config_value, timestamp))
 
@@ -574,23 +560,19 @@ def _resolve_file_sources(self, key: Optional[str] = None) -> Dict[str, Any]:
 
         for source in self._get_sources_by_type(SourceType.FILE):
             try:
-                source_data = source.discover(key)  # Already nested!
+                source_data = source.discover(key)
 
-                # Record discoveries for history tracking
                 self._history_tracker.record_nested_discovery(
                     source_data, source.source_name
                 )
 
-                # For FILE sources: connection-level replacement
                 if "connections" in source_data:
                     if "connections" not in result:
                         result["connections"] = {}
 
-                    # Replace entire connections (not merge)
                     for conn_name, conn_data in source_data["connections"].items():
                         result["connections"][conn_name] = conn_data
 
-                # Merge other top-level keys
                 for k, v in source_data.items():
                     if k != "connections":
                         result[k] = v
@@ -617,11 +599,9 @@ def _merge_file_results(
         """
         all_values: Dict[str, ConfigValue] = {}
 
-        # Add all connection parameters
         for conn_params in file_connections.values():
             all_values.update(conn_params)
 
-        # Add flat values
         all_values.update(file_flat_values)
 
         return all_values
@@ -655,58 +635,46 @@ def _apply_overlay_sources(
             try:
                 source_data = source.discover(key)
 
-                # Record discoveries for history tracking
                 self._history_tracker.record_nested_discovery(
                     source_data, source.source_name
                 )
 
-                # Separate general connection params from other data
                 general_params, other_data = extract_root_level_connection_params(
                     source_data
                 )
 
-                # First, merge connection-specific data and internal params
                 result = deep_merge(result, other_data)
 
-                # Then, merge general params into all existing connections
                 if general_params and "connections" in result and result["connections"]:
                     connection_names = [
                         name
                         for name in result["connections"]
                         if isinstance(result["connections"][name], dict)
                     ]
 
-                    # Record history for general params being merged into connections
                     self._history_tracker.record_general_params_merged_to_connections(
                         general_params, connection_names, source.source_name
                     )
 
-                    # Merge general params into existing connections
                     result["connections"] = merge_params_into_connections(
                         result["connections"], general_params
                     )
                 elif general_params:
-                    # No connections exist yet, keep general params at root
-                    # for default connection creation later
                     result = deep_merge(result, general_params)
 
             except Exception as e:
                 log.warning("Error from source %s: %s", source.source_name, e)
 
-        # Final cleanup: merge any remaining root-level general params into all connections
-        # This handles params from early sources that were added before connections existed
         if "connections" in result and result["connections"]:
             remaining_general_params, _ = extract_root_level_connection_params(result)
 
             if remaining_general_params:
-                # Merge remaining params into connections (connection values take precedence)
                 for conn_name in result["connections"]:
                     if isinstance(result["connections"][conn_name], dict):
                         result["connections"][conn_name] = deep_merge(
                             remaining_general_params, result["connections"][conn_name]
                         )
 
-                # Remove general params from root since they're now in connections
                 for key in remaining_general_params:
                     if key in result:
                         result.pop(key)
@@ -733,12 +701,10 @@ def _ensure_default_connection(self, config: Dict[str, Any]) -> Dict[str, Any]:
         """
         from snowflake.cli.api.config_ng.constants import INTERNAL_CLI_PARAMETERS
 
-        # Check if connections already exist
         connections = config.get("connections", {})
         if connections:
-            return config  # Connections exist, nothing to do
+            return config
 
-        # Identify general connection parameters (root-level, non-internal)
         general_params = {}
         for key, value in config.items():
             if (
@@ -747,20 +713,16 @@ def _ensure_default_connection(self, config: Dict[str, Any]) -> Dict[str, Any]:
             ):
                 general_params[key] = value
 
-        # If no general params, nothing to create
         if not general_params:
             return config
 
-        # Create default connection with general params
         result = config.copy()
         result["connections"] = {"default": general_params.copy()}
 
-        # Record history for moved parameters
         self._history_tracker.replicate_root_level_discoveries_to_connection(
             list(general_params.keys()), "default"
         )
 
-        # Remove general params from root level (they're now in default connection)
         for key in general_params:
             result.pop(key, None)
 
@@ -798,16 +760,12 @@ def resolve(self, key: Optional[str] = None, default: Any = None) -> Dict[str, A
         Returns:
             Nested dictionary of resolved configuration
         """
-        # Phase A: FILE sources (connection-level replacement)
         result = self._resolve_file_sources(key)
 
-        # Phase B: OVERLAY sources (field-level overlay with deep merge)
         result = self._apply_overlay_sources(result, key)
 
-        # Phase C: Ensure default connection exists if general params present
         result = self._ensure_default_connection(result)
 
-        # Phase D: Finalize resolution history
         self._finalize_resolution_history(result)
 
         return result
@@ -882,7 +840,6 @@ def get_resolution_history(self, key: str) -> Optional[ResolutionHistory]:
         Returns:
             ResolutionHistory showing the full precedence chain
         """
-        # First, try exact match
         history = self._history_tracker.get_history(key)
         if history:
             return history