dataforge-studio 1.0.1__py3-none-any.whl

dataici/blocks/load_csv.py

@@ -0,0 +1,68 @@
+import pandas as pd
+import os
+
+METADATA = {
+    "type": "load_csv",
+    "label": "Read CSV",
+    "category": "Data I/O",
+    "params": [
+        {"key": "path",           "label": "path",                 "type": "text",   "default": ""},
+        {"key": "multiple_files", "label": "read multiple files",  "type": "toggle", "default": False},
+        {"key": "name",           "label": "name",                 "type": "text",   "default": ""},
+        {"key": "sep",            "label": "sep",                  "type": "text",   "default": ","},
+        {"key": "header",         "label": "header (infer / None / int)", "type": "text", "default": "infer"},
+        {"key": "decimal",        "label": "decimal",              "type": "text",   "default": "."},
+        {"key": "thousands",      "label": "thousands",            "type": "text",   "default": ""},
+    ]
+}
+
+def run(df, params):
+    path     = params.get("path", "").strip()
+    name     = params.get("name", "").strip()
+    sep      = params.get("sep", ",") or ","
+    decimal  = params.get("decimal", ".") or "."
+    thousands = params.get("thousands", "") or None
+    multiple = params.get("multiple_files", False)
+
+    raw_header = params.get("header", "infer").strip()
+    if raw_header == "None":
+        header = None
+    elif raw_header == "infer" or raw_header == "":
+        header = "infer"
+    else:
+        try:
+            header = int(raw_header)
+        except ValueError:
+            header = "infer"
+
+    if sep == "\\t":
+        sep = "\t"
+
+    if multiple:
+        import glob
+        pattern = os.path.join(path, "*.csv")
+        files = glob.glob(pattern)
+        if not files:
+            raise FileNotFoundError(f"No se encontraron archivos CSV en: {path}")
+        dfs = [pd.read_csv(f, sep=sep, header=header, decimal=decimal, thousands=thousands) for f in sorted(files)]
+        df = pd.concat(dfs, ignore_index=True)
+        code = [
+            "import glob",
+            f'files = glob.glob("{os.path.join(path, "*.csv")}")',
+            f'df = pd.concat([pd.read_csv(f, sep="{sep}", header={repr(header)}, decimal="{decimal}") for f in sorted(files)], ignore_index=True)',
+        ]
+    else:
+        full_path = os.path.join(path, name) if name else path
+        df = pd.read_csv(full_path, sep=sep, header=header, decimal=decimal, thousands=thousands)
+        sep_r = "\\t" if sep == "\t" else sep
+        code = [
+            f'df = pd.read_csv(',
+            f'    "{full_path}",',
+            f'    sep="{sep_r}",',
+            f'    header={repr(header)},',
+            f'    decimal="{decimal}",',
+            f'    thousands={repr(thousands)}',
+            ')',
+        ]
+
+    return df, code

dataici/blocks/read_excel.py

@@ -0,0 +1,47 @@
+import pandas as pd
+import os
+
+METADATA = {
+    "type": "read_excel",
+    "label": "Read Excel",
+    "category": "Data I/O",
+    "params": [
+        {"key": "path",           "label": "path",                "type": "text",   "default": ""},
+        {"key": "multiple_files", "label": "read multiple files", "type": "toggle", "default": False},
+        {"key": "name",           "label": "name",                "type": "text",   "default": ""},
+        {"key": "header",         "label": "header (None / int)", "type": "text",   "default": "0"},
+    ]
+}
+
+def run(df, params):
+    path     = params.get("path", "").strip()
+    name     = params.get("name", "").strip()
+    multiple = params.get("multiple_files", False)
+
+    raw_header = params.get("header", "0").strip()
+    header = None if raw_header == "None" else int(raw_header) if raw_header.isdigit() else 0
+
+    if multiple:
+        import glob
+        pattern = os.path.join(path, "*.xlsx")
+        files = glob.glob(pattern)
+        if not files:
+            raise FileNotFoundError(f"No se encontraron archivos Excel en: {path}")
+        dfs = [pd.read_excel(f, header=header) for f in sorted(files)]
+        df = pd.concat(dfs, ignore_index=True)
+        code = [
+            "import glob",
+            f'files = glob.glob("{os.path.join(path, "*.xlsx")}")',
+            f'df = pd.concat([pd.read_excel(f, header={header}) for f in sorted(files)], ignore_index=True)',
+        ]
+    else:
+        full_path = os.path.join(path, name) if name else path
+        df = pd.read_excel(full_path, header=header)
+        code = [
+            f'df = pd.read_excel(',
+            f'    "{full_path}",',
+            f'    header={header}',
+            ')',
+        ]
+
+    return df, code

dataici/blocks/rename_columns.py

@@ -0,0 +1,25 @@
+METADATA = {
+    "type": "rename_columns",
+    "label": "Rename Columns",
+    "category": "Columns",
+    "params": [
+        {"key": "mapping", "label": "mapping", "type": "text", "default": ""},
+    ]
+}
+
+def run(df, params):
+    raw = params.get("mapping", "")
+    mapping = {}
+    for pair in raw.split("|"):
+        pair = pair.strip()
+        if ":" not in pair:
+            continue
+        old, new = pair.split(":", 1)
+        old, new = old.strip(), new.strip()
+        if old and new:
+            mapping[old] = new
+    if not mapping:
+        raise ValueError("Define al menos un renombrado.")
+    df = df.rename(columns=mapping)
+    code = [f"df = df.rename(columns={mapping})"]
+    return df, code

dataici/blocks/reorder_columns.py

@@ -0,0 +1,19 @@
+METADATA = {
+    "type": "reorder_columns",
+    "label": "Reorder 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("Define el orden de columnas.")
+    missing = [c for c in cols if c not in df.columns]
+    if missing:
+        raise ValueError(f"Columnas no encontradas: {missing}")
+    df = df[cols]
+    code = [f"df = df[{cols}]"]
+    return df, code

dataici/blocks/replace_values.py

@@ -0,0 +1,154 @@
+import json
+import math
+import pandas as pd
+
+METADATA = {
+    "type":     "replace_values",
+    "label":    "Replace Values",
+    "category": "DataFrame",
+    "params": [
+        {"key": "target_col",  "label": "Column to replace", "type": "text", "default": ""},
+        {"key": "with_type",   "label": "With type",         "type": "text", "default": "number"},
+        {"key": "with_value",  "label": "Value",             "type": "text", "default": ""},
+        {"key": "with_format", "label": "Datetime format",   "type": "text", "default": "%Y-%m-%d %H:%M:%S"},
+        {"key": "conditions",  "label": "Conditions (JSON)", "type": "text", "default": "[]"},
+    ]
+}
+
+
+# ── Condition mask builder ────────────────────────────────────────────────────
+def _parse_cond_value(raw, vtype, df):
+    if vtype == 'column':
+        return df[raw] if raw in df.columns else raw
+    if vtype == 'number':
+        try:
+            return float(raw) if '.' in str(raw) else int(raw)
+        except (ValueError, TypeError):
+            return raw
+    if vtype == 'datetime':
+        try:
+            return pd.Timestamp(raw)
+        except Exception:
+            return raw
+    return raw   # string
+
+
+def _single_mask(df, cond):
+    col      = cond.get('column', '')
+    operator = cond.get('operator', '==')
+    vtype    = cond.get('type', 'string')
+    raw_val  = cond.get('value', '')
+    negate   = cond.get('not', False)
+
+    if col not in df.columns:
+        return pd.Series([True] * len(df), index=df.index)
+
+    s = df[col]
+
+    if operator == 'isna':
+        mask = s.isna()
+    elif operator == 'notna':
+        mask = s.notna()
+    elif operator == 'isin':
+        vals = [v.strip() for v in str(raw_val).split(',')]
+        mask = s.isin(vals)
+    else:
+        val = _parse_cond_value(raw_val, vtype, df)
+        ops = {'==': s == val, '!=': s != val,
+               '<':  s <  val, '<=': s <= val,
+               '>':  s >  val, '>=': s >= val}
+        mask = ops.get(operator, pd.Series([True] * len(df), index=df.index))
+
+    return ~mask if negate else mask
+
+
+def _build_mask(df, conds):
+    if not conds:
+        return pd.Series([True] * len(df), index=df.index)
+    mask = _single_mask(df, conds[0])
+    for cond in conds[1:]:
+        m2      = _single_mask(df, cond)
+        logical = cond.get('logical', 'and')
+        if logical == 'or':
+            mask = mask | m2
+        elif logical == 'xor':
+            mask = mask ^ m2
+        else:
+            mask = mask & m2
+    return mask
+
+
+def _mask_repr(conds):
+    if not conds:
+        return "slice(None)"
+    parts = []
+    for c in conds:
+        col  = c.get('column', '')
+        op   = c.get('operator', '==')
+        val  = c.get('value', '')
+        not_ = 'NOT ' if c.get('not') else ''
+        parts.append(f"{not_}df['{col}'] {op} {repr(val)}")
+    return ' & '.join(f"({p})" for p in parts)
+
+
+# ── Main run ──────────────────────────────────────────────────────────────────
+def run(df, params):
+    target_col  = params.get('target_col', '').strip()
+    with_type   = params.get('with_type', 'number')
+    raw_value   = params.get('with_value', '')
+    with_format = params.get('with_format', '%Y-%m-%d %H:%M:%S').strip()
+
+    if not target_col or target_col not in df.columns:
+        raise ValueError(f"replace_values: columna '{target_col}' no encontrada en el DataFrame.")
+
+    conds = []
+    try:
+        conds = json.loads(params.get('conditions', '[]'))
+    except Exception:
+        conds = []
+
+    mask      = _build_mask(df, conds)
+    mask_repr = _mask_repr(conds)
+    code      = []
+
+    # ── number ──
+    if with_type == 'number':
+        try:
+            replacement = float(raw_value) if '.' in str(raw_value) else int(raw_value)
+        except (ValueError, TypeError):
+            replacement = 0
+        df.loc[mask, target_col] = replacement
+        code = [f"df.loc[{mask_repr}, '{target_col}'] = {repr(replacement)}"]
+
+    # ── na (NaN) ──
+    elif with_type == 'na':
+        df.loc[mask, target_col] = float('nan')
+        code = [f"df.loc[{mask_repr}, '{target_col}'] = float('nan')"]
+
+    # ── string ──
+    elif with_type == 'string':
+        df.loc[mask, target_col] = raw_value
+        code = [f"df.loc[{mask_repr}, '{target_col}'] = {repr(raw_value)}"]
+
+    # ── datetime ──
+    elif with_type == 'datetime':
+        try:
+            replacement = pd.Timestamp(raw_value)
+        except Exception:
+            raise ValueError(f"replace_values: no se pudo parsear '{raw_value}' como datetime.")
+        df.loc[mask, target_col] = replacement
+        fmt_comment = f"  # format: {with_format}" if with_format else ""
+        code = [f"df.loc[{mask_repr}, '{target_col}'] = pd.Timestamp({repr(raw_value)}){fmt_comment}"]
+
+    # ── column (copy values from another column) ──
+    elif with_type == 'column':
+        src_col = raw_value.strip()
+        if src_col not in df.columns:
+            raise ValueError(f"replace_values: columna fuente '{src_col}' no encontrada.")
+        df.loc[mask, target_col] = df.loc[mask, src_col].values
+        code = [f"df.loc[{mask_repr}, '{target_col}'] = df.loc[{mask_repr}, '{src_col}']"]
+
+    else:
+        code = [f"# replace_values: with_type='{with_type}' no reconocido"]
+
+    return df, code

dataici/blocks/resample.py

@@ -0,0 +1,68 @@
+METADATA = {
+    "type": "resample",
+    "label": "Resample",
+    "category": "Resampling",
+    "params": [
+        {"key": "rule",   "label": "Rule (ej: 1S, 1T, 2H, 1D)", "type": "text", "default": ""},
+        {"key": "sparse", "label": "Sparse resampling",          "type": "text", "default": "true"},
+        {"key": "closed", "label": "closed",                     "type": "text", "default": "None"},
+        {"key": "label",  "label": "label",                      "type": "text", "default": "None"},
+        {"key": "kind",   "label": "kind",                       "type": "text", "default": "None"},
+        {"key": "origin", "label": "origin",                     "type": "text", "default": "epoch"},
+        {"key": "offset", "label": "offset",                     "type": "text", "default": ""},
+    ]
+}
+
+# Signal to main.py that this block returns a Resampler, not a DataFrame
+IS_RESAMPLER = True
+
+
+def _parse_bool(val):
+    if isinstance(val, bool):
+        return val
+    return str(val).strip().lower() not in ("false", "0", "")
+
+
+def run(df, params):
+    import pandas as pd
+
+    rule      = (params.get("rule",   "") or "").strip()
+    sparse    = _parse_bool(params.get("sparse", "true"))
+    closed    = (params.get("closed", "None") or "None").strip()
+    label_val = (params.get("label",  "None") or "None").strip()
+    kind      = (params.get("kind",   "None") or "None").strip()
+    origin    = (params.get("origin", "epoch") or "epoch").strip()
+    offset    = (params.get("offset", "") or "").strip()
+
+    if not rule:
+        raise ValueError("resample: debes especificar una regla (e.g. '1T', '1H', '1D').")
+
+    if not isinstance(df.index, pd.DatetimeIndex):
+        raise ValueError(
+            "resample: el índice debe ser DatetimeIndex. "
+            "Usa el bloque Set Index con una columna datetime antes de este bloque."
+        )
+
+    if sparse:
+        resampler = df.resample(rule)
+        code = [f'resampler = df.resample("{rule}")']
+    else:
+        kwargs = {}
+        if closed and closed != "None":
+            kwargs["closed"] = closed
+        if label_val and label_val != "None":
+            kwargs["label"] = label_val
+        if kind and kind != "None":
+            kwargs["kind"] = kind
+        if origin:
+            kwargs["origin"] = origin
+        if offset:
+            kwargs["offset"] = offset
+
+        resampler = df.resample(rule, **kwargs)
+        kw_s = ", ".join(f"{k}={repr(v)}" for k, v in kwargs.items())
+        rule_s = f'"{rule}"' + (f", {kw_s}" if kw_s else "")
+        code = [f"resampler = df.resample({rule_s})"]
+
+    # Return the Resampler object — aggregation is done by the Aggregate block
+    return resampler, code

dataici/blocks/sample_rows.py

@@ -0,0 +1,49 @@
+METADATA = {
+    "type":     "sample_rows",
+    "label":    "Sample Rows",
+    "category": "DataFrame",
+    "params": [
+        {"key": "n",            "label": "n",            "type": "text", "default": ""},
+        {"key": "frac",         "label": "frac",         "type": "text", "default": ""},
+        {"key": "random_state", "label": "random state", "type": "text", "default": ""},
+        {"key": "ignore_index", "label": "ignore index", "type": "text", "default": "false"},
+    ]
+}
+
+
+def _parse_bool(val):
+    if isinstance(val, bool):
+        return val
+    return str(val).strip().lower() == "true"
+
+
+def run(df, params):
+    n_raw   = str(params.get("n",            "") or "").strip()
+    fr_raw  = str(params.get("frac",         "") or "").strip()
+    rs_raw  = str(params.get("random_state", "") or "").strip()
+    ignore_index = _parse_bool(params.get("ignore_index", False))
+
+    kwargs = {"ignore_index": ignore_index}
+
+    # frac takes precedence over n if both are provided
+    if fr_raw and fr_raw.lower() not in ("", "none"):
+        try:
+            kwargs["frac"] = float(fr_raw)
+        except ValueError:
+            pass
+    elif n_raw and n_raw.lower() not in ("", "none"):
+        try:
+            kwargs["n"] = int(n_raw)
+        except ValueError:
+            pass
+
+    if rs_raw and rs_raw.lower() not in ("", "none"):
+        try:
+            kwargs["random_state"] = int(rs_raw)
+        except ValueError:
+            pass
+
+    df   = df.sample(**kwargs)
+    kw_s = ", ".join(f"{k}={repr(v)}" for k, v in kwargs.items())
+    code = [f"df = df.sample({kw_s})"]
+    return df, code

dataici/blocks/select_columns.py

@@ -0,0 +1,19 @@
+METADATA = {
+    "type": "select_columns",
+    "label": "Select 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.")
+    missing = [c for c in cols if c not in df.columns]
+    if missing:
+        raise ValueError(f"Columnas no encontradas: {missing}")
+    df = df[cols]
+    code = [f"df = df[{cols}]"]
+    return df, code

dataici/blocks/set_dtypes.py

@@ -0,0 +1,46 @@
+METADATA = {
+    "type": "set_dtypes",
+    "label": "Set Dtypes",
+    "category": "DataFrame",
+    "params": [
+        {"key": "mapping", "label": "mapping", "type": "text", "default": ""},
+    ]
+}
+
+def run(df, params):
+    import pandas as pd
+    raw = params.get("mapping", "")
+    if not raw.strip():
+        raise ValueError("Especifica al menos un mapeo columna:tipo.")
+
+    dtype_map = {}
+    for pair in raw.split(";"):
+        pair = pair.strip()
+        if ":" not in pair:
+            continue
+        col, dtype = pair.split(":", 1)
+        dtype_map[col.strip()] = dtype.strip()
+
+    if not dtype_map:
+        raise ValueError("Especifica al menos un mapeo columna:tipo.")
+
+    code = []
+    for col, dtype in dtype_map.items():
+        if dtype == "datetime":
+            df[col] = pd.to_datetime(df[col], format='mixed', errors='coerce')
+            code.append(f"s = df['{col}']")
+            code.append(f"df['{col}'] = pd.to_datetime(s, format='mixed', errors='coerce')")
+        elif dtype == "numeric":
+            df[col] = pd.to_numeric(df[col], errors='coerce')
+            code.append(f"s = df['{col}']")
+            code.append(f"df['{col}'] = pd.to_numeric(s, errors='coerce')")
+        elif dtype == "categorical":
+            df[col] = df[col].astype("category")
+            code.append(f"s = df['{col}']")
+            code.append(f"df['{col}'] = s.astype('category')")
+        else:
+            df[col] = df[col].astype(dtype, errors='ignore')
+            code.append(f"s = df['{col}']")
+            code.append(f"df['{col}'] = s.astype('{dtype}')")
+
+    return df, code

dataici/blocks/set_index.py

@@ -0,0 +1,24 @@
+METADATA = {
+    "type": "set_index",
+    "label": "Set Index",
+    "category": "Index",
+    "params": [
+        {"key": "columns", "label": "columns", "type": "text", "default": ""},
+    ]
+}
+
+def run(df, params):
+    cols_raw = params.get("columns", "").strip()
+    if not cols_raw:
+        raise ValueError("Selecciona al menos una columna para usar como índice.")
+    cols = [c.strip() for c in cols_raw.split(",") if c.strip()]
+    df.set_index(cols, drop=False, inplace=True)
+    cols_repr = str(cols)
+    code = [
+        f"df.set_index(",
+        f"    {cols_repr},",
+        f"    drop=False,",
+        f"    inplace=True,",
+        f")",
+    ]
+    return df, code

dataici/blocks/write_csv.py

@@ -0,0 +1,49 @@
+import os
+
+METADATA = {
+    "type": "write_csv",
+    "label": "Write CSV",
+    "category": "Data I/O",
+    "params": [
+        {"key": "path",         "label": "path",         "type": "text",   "default": ""},
+        {"key": "name",         "label": "name",         "type": "text",   "default": "output.csv"},
+        {"key": "sep",          "label": "sep",          "type": "text",   "default": ","},
+        {"key": "na_rep",       "label": "NA rep",       "type": "text",   "default": ""},
+        {"key": "float_format", "label": "float format", "type": "text",   "default": ""},
+        {"key": "header",       "label": "header",       "type": "toggle", "default": True},
+        {"key": "index",        "label": "index",        "type": "toggle", "default": True},
+        {"key": "decimal",      "label": "decimal",      "type": "text",   "default": "."},
+    ]
+}
+
+def run(df, params):
+    path         = params.get("path", "").strip()
+    name         = params.get("name", "output.csv").strip()
+    sep          = params.get("sep", ",") or ","
+    na_rep       = params.get("na_rep", "") or ""
+    float_format = params.get("float_format", "") or None
+    header       = params.get("header", True)
+    index        = params.get("index", True)
+    decimal      = params.get("decimal", ".") or "."
+
+    if sep == "\\t":
+        sep = "\t"
+
+    full_path = os.path.join(path, name) if path else name
+
+    df.to_csv(full_path, sep=sep, na_rep=na_rep, float_format=float_format,
+              header=header, index=index, decimal=decimal)
+
+    sep_r = "\\t" if sep == "\t" else sep
+    code = [
+        f'df.to_csv(',
+        f'    "{full_path}",',
+        f'    sep="{sep_r}",',
+        f'    na_rep="{na_rep}",',
+        f'    float_format={repr(float_format)},',
+        f'    header={header},',
+        f'    index={index},',
+        f'    decimal="{decimal}"',
+        ')',
+    ]
+    return df, code