fill_missing_values

Instructions

Implementation Reference

• src/csv_editor/tools/transformations.py:415-501 (handler)

  Core implementation of fill_missing_values. Handles all strategies: 'drop', 'fill', 'forward', 'backward', 'mean', 'median', 'mode'. Records operation and returns null counts before/after.

  async def fill_missing_values(
      session_id: str,
      strategy: str = "drop",
      value: Any = None,
      columns: list[str] | None = None,
      ctx: Context = None,
  ) -> dict[str, Any]:
      """
      Fill or remove missing values.
  
      Args:
          session_id: Session identifier
          strategy: One of 'drop', 'fill', 'forward', 'backward', 'mean', 'median', 'mode'
          value: Value to fill with (for 'fill' strategy)
          columns: Specific columns to apply to (None for all)
          ctx: FastMCP context
  
      Returns:
          Dict with success status and fill info
      """
      try:
          manager = get_session_manager()
          session = manager.get_session(session_id)
  
          if not session or session.df is None:
              return {"success": False, "error": "Invalid session or no data loaded"}
  
          df = session.df
          null_counts_before = df.isnull().sum().to_dict()
  
          if columns:
              missing_cols = [col for col in columns if col not in df.columns]
              if missing_cols:
                  return {"success": False, "error": f"Columns not found: {missing_cols}"}
              target_cols = columns
          else:
              target_cols = df.columns.tolist()
  
          if strategy == "drop":
              session.df = df.dropna(subset=target_cols)
          elif strategy == "fill":
              if value is None:
                  return {"success": False, "error": "Value required for 'fill' strategy"}
              session.df[target_cols] = df[target_cols].fillna(value)
          elif strategy == "forward":
              session.df[target_cols] = df[target_cols].fillna(method="ffill")
          elif strategy == "backward":
              session.df[target_cols] = df[target_cols].fillna(method="bfill")
          elif strategy == "mean":
              for col in target_cols:
                  if df[col].dtype in ["int64", "float64"]:
                      session.df[col] = df[col].fillna(df[col].mean())
          elif strategy == "median":
              for col in target_cols:
                  if df[col].dtype in ["int64", "float64"]:
                      session.df[col] = df[col].fillna(df[col].median())
          elif strategy == "mode":
              for col in target_cols:
                  mode_val = df[col].mode()
                  if len(mode_val) > 0:
                      session.df[col] = df[col].fillna(mode_val[0])
          else:
              return {"success": False, "error": f"Unknown strategy: {strategy}"}
  
          null_counts_after = session.df.isnull().sum().to_dict()
  
          session.record_operation(
              OperationType.FILL_MISSING,
              {
                  "strategy": strategy,
                  "value": str(value) if value is not None else None,
                  "columns": target_cols,
              },
          )
  
          return {
              "success": True,
              "strategy": strategy,
              "rows_before": len(df),
              "rows_after": len(session.df),
              "null_counts_before": null_counts_before,
              "null_counts_after": null_counts_after,
          }
  
      except Exception as e:
          logger.error(f"Error filling missing values: {e!s}")
          return {"success": False, "error": str(e)}

• src/csv_editor/server.py:251-260 (handler)

  FastMCP tool decorator wrapper for fill_missing_values. Defines the tool signature and delegates to the actual implementation in tools/transformations.py.

  @mcp.tool
  async def fill_missing_values(
      session_id: str,
      strategy: str = "drop",
      value: Any = None,
      columns: list[str] | None = None,
      ctx: Context = None,
  ) -> dict[str, Any]:
      """Fill or remove missing values."""
      return await _fill_missing_values(session_id, strategy, value, columns, ctx)

• src/csv_editor/server.py:185-193 (registration)

  Import of the fill_missing_values function from the transformations module, aliased as _fill_missing_values.

  from .tools.transformations import add_column as _add_column
  from .tools.transformations import change_column_type as _change_column_type
  from .tools.transformations import fill_missing_values as _fill_missing_values
  from .tools.transformations import filter_rows as _filter_rows
  from .tools.transformations import remove_columns as _remove_columns
  from .tools.transformations import remove_duplicates as _remove_duplicates
  from .tools.transformations import rename_columns as _rename_columns
  from .tools.transformations import select_columns as _select_columns
  from .tools.transformations import sort_data as _sort_data

• src/csv_editor/server.py:77-77 (registration)

  Tool listed under 'data_manipulation' capabilities in the server's capability description.

  "fill_missing_values",