pfc-cli 0.1.0__py3-none-any.whl

pfc/commands/barplot.py

@@ -0,0 +1,64 @@
+from pfc.core.state import session
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+MAX_UNIQUE = 20
+BAR_WIDTH = 25
+BAR_CHAR = "█"
+EMPTY_CHAR = "░"
+
+
+def make_bar(value, max_value, width=BAR_WIDTH):
+    if max_value == 0:
+        return ""
+    filled = int((value / max_value) * width)
+    return BAR_CHAR * filled + EMPTY_CHAR * (width - filled)
+
+
+def run(args):
+    if session.df is None:
+        console.print("[red]No dataset loaded[/red]")
+        return
+
+    if not args:
+        console.print("[red]Usage:[/red] barplot <column>")
+        return
+
+    df = session.df.df
+    col = " ".join(args)
+
+    if col not in df.columns:
+        console.print(f"[red]Invalid column:[/red] {col}")
+        return
+
+    counts = df[col].value_counts(dropna=False)
+
+    if len(counts) > MAX_UNIQUE:
+        console.print(
+            f"[yellow]Cannot plot column '{col}':[/yellow] "
+            f"{len(counts)} unique values (limit is {MAX_UNIQUE})"
+        )
+        console.print("[dim]Tip:[/dim] Use `value_counts` instead.")
+        return
+
+    max_value = counts.max()
+
+    table = Table(
+        title=f"Bar Plot — {col}",
+        header_style="bold magenta"
+    )
+
+    table.add_column("Value")
+    table.add_column("Count", justify="right")
+    table.add_column("Bar", justify="left")
+
+    for value, count in counts.items():
+        table.add_row(
+            str(value),
+            str(count),
+            make_bar(count, max_value)
+        )
+
+    console.print(table)

pfc/commands/cls.py

@@ -0,0 +1,18 @@
+import os
+from rich.console import Console
+
+console = Console()
+
+
+def run(args):
+    # Cross-platform clear
+    os.system("cls" if os.name == "nt" else "clear")
+
+    # Optional: reprint shell header
+    console.print("[bold]pfc — Interactive Data Shell[/bold]")
+    console.print(
+        "Load a dataset once and explore it using built-in commands."
+    )
+    console.print(
+        "Type 'help' to see available commands. Type 'exit' to quit.\n"
+    )

pfc/commands/cols.py

@@ -0,0 +1,21 @@
+from pfc.core.state import session
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+
+def run(args):
+    if session.df is None:
+        console.print("[red]No dataset loaded[/red]")
+        return
+
+    table = Table(title="Columns", header_style="bold magenta")
+
+    table.add_column("Index", justify="right")
+    table.add_column("Name")
+
+    for i, col in enumerate(session.df.columns()):
+        table.add_row(str(i), col)
+
+    console.print(table)

pfc/commands/describe.py

@@ -0,0 +1,152 @@
+# from pfc.core.state import session
+# from rich.console import Console
+# from rich.table import Table
+
+# console = Console()
+
+
+# def run(args):
+#     if session.df is None:
+#         console.print("[red]No dataset loaded[/red]")
+#         return
+
+#     df = session.df.df.describe()
+
+#     table = Table(
+#         title="Dataset Description",
+#         header_style="bold magenta",
+#         row_styles=["none", "dim"]
+#     )
+
+#     table.add_column("Metric")
+
+#     for col in df.columns:
+#         table.add_column(col, justify="right")
+
+#     for idx in df.index:
+#         table.add_row(idx, *[f"{df[col][idx]:.3f}" for col in df.columns])
+
+#     console.print(table)
+
+# from pfc.core.state import session
+# from rich.console import Console
+# from rich.table import Table
+
+# console = Console()
+
+
+# def run(args):
+#     if session.df is None:
+#         console.print("[red]No dataset loaded[/red]")
+#         return
+
+#     df = session.df.df
+
+#     # ---- Select columns ----
+#     if args:
+#         cols = []
+#         for col in args:
+#             if col not in df.columns:
+#                 console.print(f"[red]Invalid column:[/red] {col}")
+#                 return
+#             cols.append(col)
+
+#         data = df[cols]
+#     else:
+#         data = df.select_dtypes(include="number")
+
+#     if data.empty:
+#         console.print("[yellow]No numeric columns to describe[/yellow]")
+#         return
+
+#     desc = data.describe()
+
+#     # ---- Render table ----
+#     table = Table(
+#         title="Dataset Description",
+#         header_style="bold magenta",
+#         row_styles=["none", "dim"]
+#     )
+
+#     table.add_column("Metric")
+
+#     for col in desc.columns:
+#         table.add_column(col, justify="right")
+
+#     for idx in desc.index:
+#         table.add_row(
+#             idx,
+#             *[f"{desc[col][idx]:.3f}" for col in desc.columns]
+#         )
+
+#     console.print(table)
+
+from pfc.core.state import session
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+
+def run(args):
+    if session.df is None:
+        console.print("[red]No dataset loaded[/red]")
+        return
+
+    df = session.df.df
+
+    # ---- Select columns ----
+    if args:
+        cols = []
+        non_numeric = []
+
+        for col in args:
+            if col not in df.columns:
+                console.print(f"[red]Invalid column:[/red] {col}")
+                return
+
+            if not df[col].dtype.kind in "iufc":  # int, unsigned, float, complex
+                non_numeric.append(col)
+            else:
+                cols.append(col)
+
+        if non_numeric:
+            console.print(
+                "[yellow]Cannot describe non-numeric column(s):[/yellow] "
+                + ", ".join(non_numeric)
+            )
+            console.print(
+                "[dim]Tip:[/dim] Use `value_counts` or `unique` for categorical columns."
+            )
+            return
+
+        data = df[cols]
+
+    else:
+        data = df.select_dtypes(include="number")
+
+    if data.empty:
+        console.print("[yellow]No numeric columns available to describe[/yellow]")
+        return
+
+    desc = data.describe()
+
+    # ---- Render table ----
+    table = Table(
+        title="Dataset Description",
+        header_style="bold magenta",
+        row_styles=["none", "dim"]
+    )
+
+    table.add_column("Metric")
+
+    for col in desc.columns:
+        table.add_column(col, justify="right")
+
+    for idx in desc.index:
+        table.add_row(
+            idx,
+            *[f"{desc[col][idx]:.3f}" for col in desc.columns]
+        )
+
+    console.print(table)

pfc/commands/groupby.py

@@ -0,0 +1,58 @@
+from pfc.core.state import session
+from pfc.ui.table import render
+from rich.console import Console
+
+console = Console()
+
+ALLOWED_AGGS = {"count", "mean", "sum", "min", "max"}
+
+
+def run(args):
+    if session.df is None:
+        console.print("[red]No dataset loaded[/red]")
+        return
+
+    if len(args) < 3:
+        console.print(
+            "[red]Usage:[/red] groupby <group_col...> <agg_column> <agg_func>"
+        )
+        console.print(
+            f"[dim]Allowed agg_func:[/dim] {', '.join(ALLOWED_AGGS)}"
+        )
+        return
+
+    df = session.df.df
+
+    agg_func = args[-1]
+    agg_col = args[-2]
+    group_cols = args[:-2]
+
+    # ---- Validate agg func ----
+    if agg_func not in ALLOWED_AGGS:
+        console.print(f"[red]Invalid aggregation function:[/red] {agg_func}")
+        return
+
+    # ---- Validate columns ----
+    for col in group_cols + [agg_col]:
+        if col not in df.columns:
+            console.print(f"[red]Invalid column:[/red] {col}")
+            return
+
+    # ---- Perform groupby ----
+    result = (
+        df
+        .groupby(group_cols)[agg_col]
+        .agg(agg_func)
+        .reset_index()
+    )
+
+    # ---- Rename aggregated column ----
+    result.rename(
+        columns={agg_col: f"{agg_func.upper()}({agg_col})"},
+        inplace=True
+    )
+
+    render(
+        result,
+        f"{session.file} (groupby {', '.join(group_cols)} → {agg_func} {agg_col})"
+    )

pfc/commands/head.py

@@ -0,0 +1,11 @@
+# pfc/commands/head.py
+from pfc.core.state import session
+from pfc.ui.table import render
+
+def run(args):
+    if session.df is None:
+        print("❌ No dataset loaded")
+        return
+
+    n = int(args[0]) if args else 5
+    render(session.df.head(n), f"{session.file} (head {n})")

pfc/commands/heatmap.py

@@ -0,0 +1,110 @@
+from pfc.core.state import session
+from rich.console import Console
+from rich.table import Table
+import pandas as pd
+import numpy as np
+
+console = Console()
+
+DEFAULT_BINS = 10
+INTENSITY = " .:-=+*#%@"
+
+def intensity_char(value, max_value):
+    if max_value == 0:
+        return " "
+    idx = int((value / max_value) * (len(INTENSITY) - 1))
+    return INTENSITY[idx]
+
+
+def run(args):
+    if session.df is None:
+        console.print("[red]No dataset loaded[/red]")
+        return
+
+    if len(args) < 2:
+        console.print(
+            "[red]Usage:[/red] heatmap <x_column> <y_column> [value_column] [--bins N]"
+        )
+        return
+
+    df = session.df.df.copy()
+
+    x_col = args[0]
+    y_col = args[1]
+    value_col = None
+    bins = DEFAULT_BINS
+
+    if "--bins" in args:
+        i = args.index("--bins")
+        try:
+            bins = int(args[i + 1])
+        except Exception:
+            console.print("[red]Bins must be an integer[/red]")
+            return
+        args = args[:i]
+
+    if len(args) == 3:
+        value_col = args[2]
+
+    for col in [x_col, y_col]:
+        if col not in df.columns:
+            console.print(f"[red]Invalid column:[/red] {col}")
+            return
+
+    if value_col and value_col not in df.columns:
+        console.print(f"[red]Invalid value column:[/red] {value_col}")
+        return
+
+    # ---- Bin numeric axes ----
+    for col in [x_col, y_col]:
+        if df[col].dtype.kind in "iufc":
+            df[col] = pd.cut(df[col], bins=bins)
+
+    # ---- Pivot ----
+    if value_col:
+        pivot = (
+            df.pivot_table(
+                index=y_col,
+                columns=x_col,
+                values=value_col,
+                aggfunc="mean",
+                observed=True
+            )
+        )
+        title = f"Heatmap — mean({value_col})"
+    else:
+        pivot = (
+            df.pivot_table(
+                index=y_col,
+                columns=x_col,
+                values=df.columns[0],
+                aggfunc="count",
+                observed=True
+            )
+        )
+        title = "Heatmap — density"
+
+    pivot = pivot.fillna(0)
+
+    max_value = pivot.values.max()
+
+    # ---- Render ----
+    table = Table(
+        title=title,
+        header_style="bold magenta",
+        show_lines=False
+    )
+
+    table.add_column("Y \\ X")
+
+    for col in pivot.columns:
+        table.add_column(str(col)[:6], justify="center")
+
+    for idx in pivot.index:
+        row = [str(idx)[:6]]
+        for col in pivot.columns:
+            char = intensity_char(pivot.loc[idx, col], max_value)
+            row.append(char)
+        table.add_row(*row)
+
+    console.print(table)

pfc/commands/help.py

@@ -0,0 +1,97 @@
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+
+def section(table, title):
+    table.add_row(
+        f"[bold magenta]{title}[/bold magenta]",
+        ""
+    )
+
+
+def run(args):
+    table = Table(
+        title="pfc — Command Reference",
+        header_style="bold magenta",
+        show_lines=False
+    )
+
+    table.add_column("Command", style="cyan", no_wrap=True)
+    table.add_column("Description", style="white")
+
+    # ── Session & Shell ──────────────────────────────
+    section(table, "Session & Shell")
+    table.add_row("help", "Show this help summary")
+    table.add_row("cls", "Clear the terminal screen (keeps dataset loaded)")
+    table.add_row("exit", "Exit the interactive shell")
+
+    table.add_row("", "")  # spacer
+
+    # ── Data Loading ─────────────────────────────────
+    section(table, "Data Loading")
+    table.add_row("load <file.csv>", "Load a CSV file into the current session")
+
+    table.add_row("", "")
+
+    # ── Data Structure & Metadata ────────────────────
+    section(table, "Data Structure & Metadata")
+    table.add_row("cols", "List all column names")
+    table.add_row("index", "Show dataset index range and preview")
+    table.add_row("size", "Show dataset dimensions (rows × columns)")
+    table.add_row("info", "Show dataset metadata and column information")
+
+    table.add_row("", "")
+
+    # ── Data Viewing ─────────────────────────────────
+    section(table, "Data Viewing")
+    table.add_row("head [n]", "Display the first n rows of the dataset (default: 5)")
+    table.add_row("tail [n]", "Display the last n rows of the dataset (default: 5)")
+
+    table.add_row("", "")
+
+    # ── Column Operations ────────────────────────────
+    section(table, "Column Operations")
+    table.add_row("select <col1> <col2> ...", "Display only the selected columns")
+    table.add_row(
+        "unique <column> [--count]",
+        "List unique values of a column (optionally with counts)",
+    )
+    table.add_row(
+        "value_counts <column> [--normalize]",
+        "Show frequency distribution of a column",
+    )
+
+    table.add_row("", "")
+
+    # ── Aggregation & Statistics ─────────────────────
+    section(table, "Aggregation & Statistics")
+    table.add_row("describe [col...]", "Statistical summary of numeric columns")
+    table.add_row(
+        "groupby <group_col...> <agg_column> <agg_func>",
+        "Group data and aggregate (count, mean, sum, min, max)",
+    )
+
+    table.add_row("", "")
+
+    # ── Visualization ────────────────────────────────
+    section(table, "Visualization")
+    table.add_row(
+        "barplot <column>",
+        "Bar plot for categorical columns (≤ 20 unique values)",
+    )
+    table.add_row(
+        "hist <column> [bins]",
+        "Histogram for a numeric column (default bins: 10)",
+    )
+    table.add_row(
+        "lineplot <x_column> <y_column> [--agg mean|sum|min|max|count]",
+        "Line plot of aggregated y-values against x-values",
+    )
+    table.add_row(
+        "heatmap <x_column> <y_column> [value_column] [--bins N]",
+        "Heatmap showing density or aggregated values",
+    )
+
+    console.print(table)

pfc/commands/histplot.py

@@ -0,0 +1,87 @@
+from pfc.core.state import session
+from rich.console import Console
+from rich.table import Table
+import numpy as np
+
+console = Console()
+
+DEFAULT_BINS = 10
+BAR_WIDTH = 25
+BAR_CHAR = "█"
+EMPTY_CHAR = "░"
+
+
+def make_bar(value, max_value, width=BAR_WIDTH):
+    if max_value == 0:
+        return ""
+    filled = int((value / max_value) * width)
+    return BAR_CHAR * filled + EMPTY_CHAR * (width - filled)
+
+
+def run(args):
+    if session.df is None:
+        console.print("[red]No dataset loaded[/red]")
+        return
+
+    if not args:
+        console.print("[red]Usage:[/red] hist <numeric_column> [bins]")
+        return
+
+    df = session.df.df
+    col = args[0]
+
+    # ---- Validate column ----
+    if col not in df.columns:
+        console.print(f"[red]Invalid column:[/red] {col}")
+        return
+
+    if not df[col].dtype.kind in "iufc":
+        console.print(
+            f"[yellow]Column '{col}' is not numeric[/yellow]"
+        )
+        console.print("[dim]Tip:[/dim] Use barplot / value_counts for categorical data.")
+        return
+
+    # ---- Bins ----
+    bins = DEFAULT_BINS
+    if len(args) > 1:
+        try:
+            bins = int(args[1])
+            if bins <= 0:
+                raise ValueError
+        except ValueError:
+            console.print("[red]Bins must be a positive integer[/red]")
+            return
+
+    data = df[col].dropna().values
+
+    if len(data) == 0:
+        console.print("[yellow]No data available for histogram[/yellow]")
+        return
+
+    # ---- Compute histogram ----
+    counts, edges = np.histogram(data, bins=bins)
+    max_count = counts.max()
+
+    # ---- Build table ----
+    table = Table(
+        title=f"Histogram — {col} ({bins} bins)",
+        header_style="bold magenta"
+    )
+
+    table.add_column("Range")
+    table.add_column("Count", justify="right")
+    table.add_column("Bar")
+
+    for i in range(len(counts)):
+        left = edges[i]
+        right = edges[i + 1]
+        label = f"{left:.2f} – {right:.2f}"
+
+        table.add_row(
+            label,
+            str(counts[i]),
+            make_bar(counts[i], max_count)
+        )
+
+    console.print(table)

pfc/commands/index.py

@@ -0,0 +1,52 @@
+from pfc.core.state import session
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+PREVIEW_COUNT = 10
+
+
+def run(args):
+    if session.df is None:
+        console.print("[red]No dataset loaded[/red]")
+        return
+
+    df = session.df.df  # pandas DataFrame
+    index = df.index
+
+    start_idx = index[0]
+    end_idx = index[-1]
+    total = len(index)
+
+    # ---- Summary table ----
+    summary = Table(
+        title="Index Summary",
+        header_style="bold magenta"
+    )
+
+    summary.add_column("Start Index", justify="right")
+    summary.add_column("End Index", justify="right")
+    summary.add_column("Total Rows", justify="right")
+
+    summary.add_row(
+        str(start_idx),
+        str(end_idx),
+        str(total)
+    )
+
+    console.print(summary)
+
+    # ---- Preview table ----
+    preview = Table(
+        title=f"First {min(PREVIEW_COUNT, total)} Index Values",
+        header_style="bold magenta"
+    )
+
+    preview.add_column("Position", justify="right")
+    preview.add_column("Index Value", justify="right")
+
+    for i, idx in enumerate(index[:PREVIEW_COUNT]):
+        preview.add_row(str(i), str(idx))
+
+    console.print(preview)