dataforge-studio 1.0.1__py3-none-any.whl

dataforge_studio-1.0.1.dist-info/METADATA

@@ -0,0 +1,119 @@
+Metadata-Version: 2.4
+Name: dataforge-studio
+Version: 1.0.1
+Summary: Studio visual de preprocesamiento de datos — Universidad Alberto Hurtado
+Author-email: Álvaro Riquelme <alvaroriquelme.14@gmail.com>
+License-Expression: LicenseRef-Proprietary
+Project-URL: Homepage, https://dataforgeUAH.github.io/dataici
+Keywords: data,preprocessing,pandas,visual,pipeline,uah
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Intended Audience :: Education
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi>=0.110.0
+Requires-Dist: uvicorn[standard]>=0.29.0
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: openpyxl>=3.1.0
+Requires-Dist: python-multipart>=0.0.9
+Requires-Dist: matplotlib>=3.7.0
+Requires-Dist: numpy>=1.24.0
+
+# DataICI — v0.2
+
+Herramienta visual de preprocesamiento de datos para estudiantes de Ingeniería Civil Industrial.
+
+## Requisitos previos
+- Python 3.9+ → https://python.org
+- Node.js 18+ → https://nodejs.org
+
+---
+
+## Instalación y ejecución
+
+### 1. Backend (FastAPI + pandas)
+
+Abre una terminal en la carpeta `dataici/`:
+
+```bash
+# Windows
+cd backend
+pip install -r requirements.txt
+uvicorn main:app --reload
+
+# Mac
+cd backend
+pip3 install -r requirements.txt
+uvicorn main:app --reload
+```
+
+Backend corriendo en: http://localhost:8000
+
+---
+
+### 2. Frontend (React)
+
+Abre **otra terminal**:
+
+```bash
+cd frontend
+npm install
+npm run dev
+```
+
+App disponible en: http://localhost:5173
+
+---
+
+## Estructura del proyecto
+
+```
+dataici/
+├── backend/
+│   ├── main.py                ← API FastAPI
+│   ├── requirements.txt
+│   └── blocks/                ← un archivo por bloque
+│       ├── load_csv.py
+│       ├── drop_nulls.py
+│       ├── filter_rows.py
+│       ├── groupby.py
+│       └── export_csv.py
+│
+└── frontend/
+    ├── package.json
+    ├── vite.config.js
+    └── src/
+        ├── App.jsx              ← app principal
+        ├── nodes/
+        │   └── BlockNode.jsx    ← nodo del canvas
+        └── panels/
+            ├── Sidebar.jsx      ← bloques disponibles
+            ├── ParamsPanel.jsx  ← parámetros del bloque
+            └── PreviewPanel.jsx ← resultados
+```
+
+---
+
+## Cómo agregar un nuevo bloque
+
+Solo crear `backend/blocks/nuevo_bloque.py`. El frontend lo detecta automáticamente.
+
+```python
+METADATA = {
+    "type": "mi_bloque",
+    "label": "Mi bloque",
+    "category": "Limpieza",   # Entrada / Salida | Limpieza | Análisis
+    "params": [
+        {"key": "columna", "label": "Columna", "type": "text", "default": ""},
+        {"key": "metodo", "label": "Método", "type": "select", "options": ["a", "b"], "default": "a"},
+        {"key": "activo", "label": "Activar", "type": "toggle", "default": False},
+    ]
+}
+
+def run(df, params):
+    col = params.get("columna")
+    df = df.drop(columns=[col])
+    code = [f'df = df.drop(columns=["{col}"])']
+    return df, code
+```

dataforge_studio-1.0.1.dist-info/RECORD

@@ -0,0 +1,30 @@
+dataici/__init__.py,sha256=UE3F0RhOupkC8xJmkgpfCieOZIHNiIr0dIPU-5MHeTU,102
+dataici/charts.py,sha256=0Lik7kYvjq5YQUEq6I5xOuF2-vaRE2_bRkTrkNDWJBc,7109
+dataici/cli.py,sha256=UqapIUK07u6ZDe3gbsu1dUC5OW1f6rN56grpdChP9B8,936
+dataici/main.py,sha256=lTPXKgcpWZQgno8lhSKrhKclauBMM-XBVRaMVUCGIlQ,12376
+dataici/blocks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dataici/blocks/aggregate.py,sha256=yO5O58k33eZ9V14V-iQtCOUgaMy6UYCzKaTslKULNoc,1606
+dataici/blocks/append_column.py,sha256=WcLm6EkZ8FJPkl22ddbikQF5EBYVmlyR4SobZ7mJijw,501
+dataici/blocks/concatenate.py,sha256=ejaCTbY0Ak9NXKFvRx7R3Vyqn7TGxNFBztUTNpghqo4,3103
+dataici/blocks/drop_columns.py,sha256=7XgB8AOpOvqcHozBkw-v1rnV69NS_xyR5PIxmSQ1tpQ,627
+dataici/blocks/filter_rows.py,sha256=2C8or2xO3Qrlh2KsoyeYK2wJROk3sg6MyyJtG4z2Ub4,4376
+dataici/blocks/handle_missings.py,sha256=1SiCLujj4JDZPGHw6Ekj17FZjL7fBCNeK6FnEMGpvS0,7351
+dataici/blocks/load_csv.py,sha256=gQcn1bm1tokDYqk_TfHxZu7JBYyELazsOTsOiNRS-BM,2692
+dataici/blocks/read_excel.py,sha256=XCyOBNNwFLXzoqRk51vXEQfKw2ye32JoaSYfEVVfu-s,1738
+dataici/blocks/rename_columns.py,sha256=NyhkgcgDmd_agus2wLZqoetaWZzdYTJnBFRc8U8ZRaw,710
+dataici/blocks/reorder_columns.py,sha256=eyp5Cdthhm2c7D0pcji9eMerPhC1gYmjAdYrDJE1MVc,589
+dataici/blocks/replace_values.py,sha256=GjlLmDTE4GWuCl8G_lyhg29C1NvyGK3sGiUiuA9-NFc,5521
+dataici/blocks/resample.py,sha256=S_jrFBM4Hd5hIkmmcIfQeQ1K46XNTMg6gDehhYbxZSo,2697
+dataici/blocks/sample_rows.py,sha256=GXxaBpw8X5YpfCU52V5XhyyG65OG-tQpb0lNjAhSip8,1611
+dataici/blocks/select_columns.py,sha256=vm4LgKBPwdw4_qugoWwQxavlfMmmU9qOR17svoQoJ7o,591
+dataici/blocks/set_dtypes.py,sha256=bTwfqMXAN_4lr1BuS2OVjtTYg5gh_7MLYfPeF4tJBIo,1599
+dataici/blocks/set_index.py,sha256=AgruV2FTYtQsLh-tFbjClraqc0g58t07eQcRDkU7mjE,674
+dataici/blocks/write_csv.py,sha256=UhNE7fhZAfFoRpkrHs_OXtKNu1kkGvkLSXh0BmjKk2U,1907
+dataici/static/index.html,sha256=ISU1RFLD_nyMQx0F02JpS3XFSsDvQN7djnxEwWT4l-o,394
+dataici/static/assets/index-CYGnphoW.js,sha256=g5zsPhlYAdY4Le_0ziC3FUGZ-w6CgV4ZzlGO0lyUqcU,487756
+dataici/static/assets/index-DLK3-mBP.css,sha256=BRbWdZ92-il_sC1qbpDqlb9TBKn5sJ5dGREYT8Q9D-s,16169
+dataforge_studio-1.0.1.dist-info/METADATA,sha256=6Q8sSmWVZYz9YFBF-t9YxQEpGByxq05ea4LOrrVsQag,3122
+dataforge_studio-1.0.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+dataforge_studio-1.0.1.dist-info/entry_points.txt,sha256=WPUWatbninyQUv7yeZUL_46_kSM36g4i_OIQzyKSNPE,45
+dataforge_studio-1.0.1.dist-info/top_level.txt,sha256=GSq62DNLl7S05BlvprGvsaye2dBNocMXqIxxrFvJif4,8
+dataforge_studio-1.0.1.dist-info/RECORD,,

dataforge_studio-1.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dataforge_studio-1.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dataici = dataici.cli:main

dataforge_studio-1.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+dataici

dataici/__init__.py

@@ -0,0 +1,3 @@
+# DataICI — Studio de Preprocesamiento de Datos
+# Universidad Alberto Hurtado
+__version__ = "1.0.0"

dataici/blocks/aggregate.py

@@ -0,0 +1,50 @@
+import json
+
+METADATA = {
+    "type":     "aggregate",
+    "label":    "Aggregate",
+    "category": "Resampling",
+    "params": [
+        {"key": "custom",    "label": "Custom Functions",  "type": "text", "default": "false"},
+        {"key": "func",      "label": "General function",  "type": "text", "default": "mean"},
+        {"key": "col_funcs", "label": "Per-column funcs",  "type": "text", "default": "{}"},
+    ]
+}
+
+# pandas resampler does not have a .unique() — map to nunique
+_ALIASES = {"unique": "nunique"}
+
+
+def _is_resampler(obj):
+    try:
+        from pandas.core.resample import DatetimeIndexResampler
+        return isinstance(obj, DatetimeIndexResampler)
+    except ImportError:
+        pass
+    return hasattr(obj, "_selected_obj") and not hasattr(obj, "to_dict")
+
+
+def run(obj, params):
+    custom       = str(params.get("custom",    "false")).strip().lower() == "true"
+    func         = (params.get("func",         "mean") or "mean").strip()
+    col_funcs_raw = params.get("col_funcs", "{}")
+
+    try:
+        col_funcs = json.loads(col_funcs_raw) if col_funcs_raw else {}
+    except Exception:
+        col_funcs = {}
+
+    is_rs  = _is_resampler(obj)
+    prefix = "resampler" if is_rs else "df"
+
+    if custom and col_funcs:
+        # Map aliases per-column
+        mapped = {col: _ALIASES.get(fn, fn) for col, fn in col_funcs.items()}
+        df   = obj.agg(mapped)
+        code = [f"df = {prefix}.agg({json.dumps(mapped)})"]
+    else:
+        actual = _ALIASES.get(func, func)
+        df   = getattr(obj, actual)()
+        code = [f"df = {prefix}.{actual}()"]
+
+    return df, code

dataici/blocks/append_column.py

@@ -0,0 +1,18 @@
+import numpy as np
+import pandas as pd
+METADATA = {
+    "type": "append_column",
+    "label": "Append a Column",
+    "category": "Columns",
+    "params": [
+        {"key": "colname", "label": "colname", "type": "text", "default": "new_col"},
+    ]
+}
+
+def run(df, params):
+    colname = params.get("colname", "new_col").strip()
+    if not colname:
+        raise ValueError("Especifica el nombre de la nueva columna.")
+    df[colname] = 'None'
+    code = [f'df["{colname}"] = None']
+    return df, code

dataici/blocks/concatenate.py

@@ -0,0 +1,70 @@
+import pandas as pd
+
+METADATA = {
+    "type":        "concatenate",
+    "label":       "Concatenate",
+    "category":    "DataFrame",
+    "multi_input": True,
+    "params": [
+        {"key": "input_count",      "label": "Número de entradas",    "type": "text",   "default": "2"},
+        {"key": "axis",             "label": "Axis",                  "type": "text",   "default": "index"},
+        {"key": "join",             "label": "Join",                  "type": "text",   "default": "outer"},
+        {"key": "change_col_names", "label": "Change column names",   "type": "text",   "default": "None"},
+        {"key": "ignore_index",     "label": "Ignore index",          "type": "text",   "default": "false"},
+        {"key": "sort",             "label": "Sort",                  "type": "text",   "default": "false"},
+    ]
+}
+
+
+def _bool(val):
+    if isinstance(val, bool):
+        return val
+    return str(val).strip().lower() == "true"
+
+
+def run(dfs, params):
+    """dfs: list of DataFrames received from upstream nodes."""
+    axis_raw = params.get("axis", "index")
+    axis     = 0 if axis_raw == "index" else 1
+
+    join          = params.get("join", "outer")
+    change_cols   = params.get("change_col_names", "None")   # None | prefix | suffix
+    ignore_index  = _bool(params.get("ignore_index", False))
+    sort          = _bool(params.get("sort", False))
+
+    if len(dfs) < 2:
+        raise ValueError("Concatenate necesita al menos 2 DataFrames.")
+
+    # ── Rename columns when axis=1 and change_col_names != None ──────────────
+    if axis == 1 and change_cols in ("prefix", "suffix"):
+        renamed = []
+        for i, df in enumerate(dfs):
+            if change_cols == "prefix":
+                df = df.rename(columns=lambda c: f"df{i+1}_{c}")
+            else:
+                df = df.rename(columns=lambda c: f"{c}_df{i+1}")
+            renamed.append(df)
+        dfs = renamed
+
+    # ── Build concat kwargs ───────────────────────────────────────────────────
+    kwargs = {"axis": axis, "join": join, "sort": sort}
+    if axis == 0:
+        kwargs["ignore_index"] = ignore_index
+
+    df_result = pd.concat(dfs, **kwargs)
+
+    # ── Code string ──────────────────────────────────────────────────────────
+    frames_repr = ", ".join(f"df_{i+1}" for i in range(len(dfs)))
+    code_lines  = []
+
+    if axis == 1 and change_cols == "prefix":
+        for i in range(len(dfs)):
+            code_lines.append(f"df_{i+1} = df_{i+1}.rename(columns=lambda c: f'df{i+1}_{{c}}')")
+    elif axis == 1 and change_cols == "suffix":
+        for i in range(len(dfs)):
+            code_lines.append(f"df_{i+1} = df_{i+1}.rename(columns=lambda c: f'{{c}}_df{i+1}')")
+
+    kw_str = ", ".join(f"{k}={repr(v)}" for k, v in kwargs.items())
+    code_lines.append(f"df = pd.concat([{frames_repr}], {kw_str})")
+
+    return df_result, code_lines

dataici/blocks/drop_columns.py

@@ -0,0 +1,19 @@
+METADATA = {
+    "type": "drop_columns",
+    "label": "Drop Columns",
+    "category": "Columns",
+    "params": [
+        {"key": "columns", "label": "columns", "type": "text", "default": ""},
+    ]
+}
+
+def run(df, params):
+    cols = [c.strip() for c in params.get("columns", "").split(",") if c.strip()]
+    if not cols:
+        raise ValueError("Selecciona al menos una columna para eliminar.")
+    missing = [c for c in cols if c not in df.columns]
+    if missing:
+        raise ValueError(f"Columnas no encontradas: {missing}")
+    df = df.drop(columns=cols)
+    code = [f"df = df.drop(columns={cols})"]
+    return df, code

dataici/blocks/filter_rows.py

@@ -0,0 +1,120 @@
+import json
+import pandas as pd
+
+METADATA = {
+    "type": "filter_rows",
+    "label": "Filter Rows",
+    "category": "DataFrame",
+    "params": [
+        {"key": "conditions", "label": "conditions", "type": "text", "default": "[]"},
+    ]
+}
+
+def run(df, params):
+    raw = params.get("conditions", "[]")
+    try:
+        conditions = json.loads(raw) if isinstance(raw, str) else raw
+    except Exception:
+        raise ValueError("Error al leer las condiciones.")
+
+    if not conditions:
+        raise ValueError("Agrega al menos una condición Where.")
+
+    OP_METHOD = {"==": "eq", "!=": "ne", "<": "lt", "<=": "le", ">": "gt", ">=": "ge"}
+    OP_SYM    = {"and": "&", "or": "|", "xor": "^"}
+
+    masks      = []
+    cond_lines = []
+
+    for i, cond in enumerate(conditions):
+        col     = cond.get("column", "")
+        op      = cond.get("operator", "==")
+        typ     = cond.get("type", "number")
+        val     = str(cond.get("value", "0")).strip()
+        negate  = cond.get("not", False)
+        logical = cond.get("logical", "and")
+
+        if not col or col not in df.columns:
+            raise ValueError(f"Columna '{col}' no encontrada en el DataFrame.")
+
+        s = df[col]
+
+        # ── Build mask ───────────────────────────────────────────────────────
+        if op == "isna":
+            mask      = s.isna()
+            code_expr = f"df['{col}'].isna()"
+
+        elif op == "notna":
+            mask      = s.notna()
+            code_expr = f"df['{col}'].notna()"
+
+        elif op == "isin":
+            items = [v.strip() for v in val.split(",") if v.strip()]
+            if typ == "number":
+                try:
+                    parsed = [float(v) for v in items]
+                except ValueError:
+                    raise ValueError(f"isin numérico: valores inválidos → {items}")
+                code_expr = f"df['{col}'].isin({parsed})"
+            else:
+                parsed    = [v.strip("'\"") for v in items]
+                code_expr = f"df['{col}'].isin({parsed!r})"
+            mask = s.isin(parsed)
+
+        else:
+            method = OP_METHOD.get(op, "eq")
+
+            if typ == "number":
+                try:
+                    parsed = float(val)
+                except ValueError:
+                    raise ValueError(f"Valor numérico inválido: '{val}'")
+                mask      = getattr(s, method)(parsed)
+                code_expr = f"df['{col}'].{method}({parsed})"
+
+            elif typ == "string":
+                parsed    = val.strip("'\"")
+                mask      = getattr(s, method)(parsed)
+                code_expr = f"df['{col}'].{method}('{parsed}')"
+
+            elif typ == "datetime":
+                try:
+                    parsed = pd.Timestamp(val)
+                except Exception:
+                    raise ValueError(f"Fecha inválida: '{val}'")
+                mask      = getattr(s, method)(parsed)
+                code_expr = f"df['{col}'].{method}(pd.Timestamp('{val}'))"
+
+            elif typ == "column":
+                if val not in df.columns:
+                    raise ValueError(f"Columna de comparación '{val}' no existe.")
+                mask      = getattr(s, method)(df[val])
+                code_expr = f"df['{col}'].{method}(df['{val}'])"
+
+            else:
+                raise ValueError(f"Tipo desconocido: '{typ}'")
+
+        if negate:
+            mask      = ~mask
+            code_expr = f"~({code_expr})"
+
+        masks.append({"logical": logical, "mask": mask, "expr": code_expr})
+
+    # ── Combine masks ────────────────────────────────────────────────────────
+    result_mask = masks[0]["mask"]
+    cond_lines  = [f"    ({masks[0]['expr']})"]
+
+    for m in masks[1:]:
+        sym = OP_SYM.get(m["logical"], "&")
+        if m["logical"] == "and":
+            result_mask = result_mask & m["mask"]
+        elif m["logical"] == "or":
+            result_mask = result_mask | m["mask"]
+        elif m["logical"] == "xor":
+            result_mask = result_mask ^ m["mask"]
+        cond_lines.append(f"    {sym} ({m['expr']})")
+
+    df = df[result_mask]
+
+    code = ["cond = (", *cond_lines, ")", "df = df[cond]"]
+    return df, code

dataici/blocks/handle_missings.py

@@ -0,0 +1,160 @@
+METADATA = {
+    "type": "handle_missings",
+    "label": "Handle Missings",
+    "category": "DataFrame",
+    "params": [
+        {"key": "all_columns",              "label": "All Columns",      "type": "text", "default": "true"},
+        {"key": "columns",                  "label": "Columns",          "type": "text", "default": ""},
+        {"key": "operation",                "label": "Operation",        "type": "text", "default": "dropna"},
+        # dropna
+        {"key": "axis",                     "label": "Axis",             "type": "text", "default": "index"},
+        {"key": "how",                      "label": "How",              "type": "text", "default": "any"},
+        {"key": "thresh",                   "label": "Thresh (%)",       "type": "text", "default": ""},
+        # fillna
+        {"key": "fill_type",                "label": "Fill Type",        "type": "text", "default": "value"},
+        {"key": "value_type",               "label": "Value Type",       "type": "text", "default": "number"},
+        {"key": "fill_value",               "label": "Fill Value",       "type": "text", "default": "0"},
+        {"key": "fill_method",              "label": "Fill Method",      "type": "text", "default": "ffill"},
+        {"key": "fill_axis",                "label": "Fill Axis",        "type": "text", "default": "index"},
+        {"key": "fill_limit",               "label": "Fill Limit",       "type": "text", "default": ""},
+        # interpolate
+        {"key": "interp_method",            "label": "Interp Method",    "type": "text", "default": "linear"},
+        {"key": "interp_axis",              "label": "Interp Axis",      "type": "text", "default": "index"},
+        {"key": "interp_limit",             "label": "Interp Limit",     "type": "text", "default": ""},
+        {"key": "interp_limit_direction",   "label": "Limit Direction",  "type": "text", "default": "None"},
+        {"key": "interp_limit_area",        "label": "Limit Area",       "type": "text", "default": "None"},
+    ]
+}
+
+
+def _parse_limit(raw):
+    """Return int or None."""
+    try:
+        v = int(str(raw).strip())
+        return v if v > 0 else None
+    except (ValueError, TypeError):
+        return None
+
+
+def run(df, params):
+    operation   = params.get("operation", "dropna")
+    all_columns = params.get("all_columns", "true").strip().lower() != "false"
+    columns_raw = params.get("columns", "")
+    subset      = (
+        [c.strip() for c in columns_raw.split(",") if c.strip()]
+        if not all_columns and columns_raw.strip()
+        else None
+    )
+
+    code = []
+
+    # ── dropna ────────────────────────────────────────────────────────────────
+    if operation == "dropna":
+        axis      = params.get("axis", "index")
+        how       = params.get("how", "any")
+        thresh_raw = params.get("thresh", "").strip()
+
+        kwargs = {"axis": axis}
+        if subset:
+            kwargs["subset"] = subset
+
+        if thresh_raw:
+            try:
+                thresh_pct = float(thresh_raw)
+                # thresh = minimum number of non-NA values required to keep row/col
+                n = df.shape[0] if axis in ("index", "0") else df.shape[1]
+                kwargs["thresh"] = max(1, int(thresh_pct / 100.0 * n))
+                # thresh and how are mutually exclusive — omit how
+            except (ValueError, TypeError):
+                kwargs["how"] = how
+        else:
+            kwargs["how"] = how
+
+        df   = df.dropna(**kwargs)
+        code = [f"df = df.dropna({', '.join(f'{k}={repr(v)}' for k, v in kwargs.items())})"]
+
+    # ── fillna ────────────────────────────────────────────────────────────────
+    elif operation == "fillna":
+        fill_type = params.get("fill_type", "value")
+
+        if fill_type == "value":
+            value_type = params.get("value_type", "number")
+            raw_val    = params.get("fill_value", "0")
+            if value_type == "number":
+                try:
+                    fill_val = float(raw_val) if "." in str(raw_val) else int(raw_val)
+                except (ValueError, TypeError):
+                    fill_val = 0
+            else:
+                fill_val = raw_val
+
+            if subset:
+                df[subset] = df[subset].fillna(fill_val)
+                code = [f"df[{subset}] = df[{subset}].fillna({repr(fill_val)})"]
+            else:
+                df   = df.fillna(fill_val)
+                code = [f"df = df.fillna({repr(fill_val)})"]
+
+        else:  # method
+            method    = params.get("fill_method", "ffill")
+            fill_axis = params.get("fill_axis", "index")
+            limit     = _parse_limit(params.get("fill_limit", ""))
+            axis_val  = None if fill_axis in ("None", "") else fill_axis
+
+            extra = {}
+            if axis_val:
+                extra["axis"] = axis_val
+            if limit:
+                extra["limit"] = limit
+
+            if method == "ffill":
+                fn = "ffill"
+                if subset:
+                    df[subset] = df[subset].ffill(**extra)
+                    code = [f"df[{subset}] = df[{subset}].ffill({_fmt(extra)})"]
+                else:
+                    df   = df.ffill(**extra)
+                    code = [f"df = df.ffill({_fmt(extra)})"]
+            elif method == "bfill":
+                fn = "bfill"
+                if subset:
+                    df[subset] = df[subset].bfill(**extra)
+                    code = [f"df[{subset}] = df[{subset}].bfill({_fmt(extra)})"]
+                else:
+                    df   = df.bfill(**extra)
+                    code = [f"df = df.bfill({_fmt(extra)})"]
+            else:
+                # method == "None" — no-op
+                code = ["# fillna: method=None — no action taken"]
+
+    # ── interpolate ───────────────────────────────────────────────────────────
+    elif operation == "interpolate":
+        imethod    = params.get("interp_method", "linear")
+        iaxis      = params.get("interp_axis", "index")
+        limit      = _parse_limit(params.get("interp_limit", ""))
+        limit_dir  = params.get("interp_limit_direction", "None")
+        limit_area = params.get("interp_limit_area", "None")
+
+        kwargs = {"method": imethod}
+        if iaxis and iaxis != "None":
+            kwargs["axis"] = iaxis
+        if limit:
+            kwargs["limit"] = limit
+        if limit_dir and limit_dir != "None":
+            kwargs["limit_direction"] = limit_dir
+        if limit_area and limit_area != "None":
+            kwargs["limit_area"] = limit_area
+
+        if subset:
+            df[subset] = df[subset].interpolate(**kwargs)
+            code = [f"df[{subset}] = df[{subset}].interpolate({_fmt(kwargs)})"]
+        else:
+            df   = df.interpolate(**kwargs)
+            code = [f"df = df.interpolate({_fmt(kwargs)})"]
+
+    return df, code
+
+
+def _fmt(kwargs):
+    """Format a dict as keyword arguments string."""
+    return ", ".join(f"{k}={repr(v)}" for k, v in kwargs.items())