pfc-cli 0.1.0__py3-none-any.whl

pfc/commands/info.py

@@ -0,0 +1,61 @@
+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  # pandas DataFrame
+
+    rows, cols = df.shape
+    mem_bytes = df.memory_usage(deep=True).sum()
+    mem_mb = mem_bytes / (1024 * 1024)
+
+    # ---------------- Summary ----------------
+    summary = Table(
+        title="Dataset Info",
+        header_style="bold magenta"
+    )
+
+    summary.add_column("Property")
+    summary.add_column("Value", justify="right")
+
+    summary.add_row("File", session.file)
+    summary.add_row("Rows", str(rows))
+    summary.add_row("Columns", str(cols))
+    summary.add_row("Memory Usage", f"{mem_mb:.2f} MB")
+
+    console.print(summary)
+
+    # ---------------- Column Info ----------------
+    col_table = Table(
+        title="Column Information",
+        header_style="bold magenta"
+    )
+
+    col_table.add_column("Column")
+    col_table.add_column("Dtype")
+    col_table.add_column("Non-Null", justify="right")
+    col_table.add_column("Nulls", justify="right")
+    col_table.add_column("Null %", justify="right")
+
+    for col in df.columns:
+        total = len(df)
+        non_null = df[col].count()
+        nulls = total - non_null
+        null_pct = (nulls / total) * 100 if total else 0
+
+        col_table.add_row(
+            col,
+            str(df[col].dtype),
+            str(non_null),
+            str(nulls),
+            f"{null_pct:.2f}%"
+        )
+
+    console.print(col_table)

pfc/commands/lineplot.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
+
+console = Console()
+
+MAX_RENDER_POINTS = 50
+HEIGHT = 10
+POINT_CHAR = "●"
+EMPTY_CHAR = " "
+
+
+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] lineplot <x_column> <y_column> [--agg mean|sum|min|max|count]")
+        return
+
+    df = session.df.df
+
+    x_col = args[0]
+    y_col = args[1]
+
+    agg = "mean"
+    if "--agg" in args:
+        idx = args.index("--agg")
+        try:
+            agg = args[idx + 1]
+        except IndexError:
+            console.print("[red]Missing aggregation after --agg[/red]")
+            return
+
+    if x_col not in df.columns:
+        console.print(f"[red]Invalid x column:[/red] {x_col}")
+        return
+
+    if y_col not in df.columns:
+        console.print(f"[red]Invalid y column:[/red] {y_col}")
+        return
+
+    if not df[y_col].dtype.kind in "iufc":
+        console.print(f"[red]Y column must be numeric:[/red] {y_col}")
+        return
+
+    if agg not in {"mean", "sum", "min", "max", "count"}:
+        console.print("[red]Invalid aggregation[/red]")
+        return
+
+    # ---- Aggregate ----
+    grouped = (
+        df.groupby(x_col)[y_col]
+        .agg(agg)
+        .reset_index()
+        .sort_values(x_col)
+    )
+
+    n_points = len(grouped)
+    step = 1
+
+    if n_points > MAX_RENDER_POINTS:
+        step = (n_points + MAX_RENDER_POINTS - 1) // MAX_RENDER_POINTS
+        grouped = grouped.iloc[::step].reset_index(drop=True)
+
+        console.print(
+            f"[dim]Downsampling applied:[/dim] showing every {step} point "
+            f"({len(grouped)} of {n_points})"
+        )
+
+
+    y_values = grouped[y_col].values
+    y_min, y_max = y_values.min(), y_values.max()
+
+    # Normalize Y to HEIGHT
+    def scale(y):
+        if y_max == y_min:
+            return HEIGHT // 2
+        return int((y - y_min) / (y_max - y_min) * (HEIGHT - 1))
+
+    scaled = [scale(y) for y in y_values]
+
+    # ---- Build plot grid ----
+    grid = [[EMPTY_CHAR] * len(scaled) for _ in range(HEIGHT)]
+
+    for x, y in enumerate(scaled):
+        grid[HEIGHT - 1 - y][x] = POINT_CHAR
+
+    # ---- Render ----
+    table = Table(
+        title=f"Line Plot — {y_col} vs {x_col} ({agg})",
+        header_style="bold magenta"
+    )
+
+    table.add_column("Y")
+    table.add_column("Plot")
+
+    for i, row in enumerate(grid):
+        y_label = f"{y_max - i * (y_max - y_min) / (HEIGHT - 1):.2f}"
+        table.add_row(y_label, "".join(row))
+
+    table.add_row("", "-" * len(scaled))
+    table.add_row("X", " ".join(str(x)[:1] for x in grouped[x_col]))
+
+    console.print(table)
+    console.print(
+        "[dim]Note:[/dim] X-axis is sampled; gaps reflect uneven data distribution."
+    )

pfc/commands/load.py

@@ -0,0 +1,24 @@
+from pfc.core.state import session
+from pfc.core.dataset import Dataset
+from rich.console import Console
+
+console = Console()
+
+
+def run(args):
+    if not args:
+        console.print("[red]Usage:[/red] load <file.csv>")
+        return
+
+    path = args[0]
+
+    try:
+        dataset = Dataset(path)
+    except Exception as e:
+        console.print(f"[red]Failed to load CSV:[/red] {e}")
+        return
+
+    session.df = dataset
+    session.file = path
+
+    console.print(f"[bold green]Loaded[/bold green] {path}")

pfc/commands/select.py

@@ -0,0 +1,37 @@
+from pfc.core.state import session
+from pfc.ui.table import render
+from rich.console import Console
+
+console = Console()
+
+
+def run(args):
+    if session.df is None:
+        console.print("[red]No dataset loaded[/red]")
+        return
+
+    if not args:
+        console.print("[red]Usage:[/red] select <col1> <col2> ...")
+        return
+
+    df = session.df.df  # pandas DataFrame
+    available_cols = list(df.columns)
+
+    # Handle column names with spaces (already split by shell)
+    selected_cols = args
+
+    # Validate columns
+    invalid = [c for c in selected_cols if c not in available_cols]
+    if invalid:
+        console.print(
+            f"[red]Invalid column(s):[/red] {', '.join(invalid)}"
+        )
+        console.print(
+            f"[dim]Available columns:[/dim] {', '.join(available_cols)}"
+        )
+        return
+
+    # Select columns (NON-MUTATING)
+    result = df[selected_cols].copy()
+
+    render(result, f"{session.file} (select: {', '.join(selected_cols)})")

pfc/commands/size.py

@@ -0,0 +1,26 @@
+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  # pandas DataFrame
+
+    rows, cols = df.shape
+    total = rows * cols
+
+    table = Table(title="Dataset Size", header_style="bold magenta")
+
+    table.add_column("Rows", justify="right")
+    table.add_column("Columns", justify="right")
+    table.add_column("Total Cells", justify="right")
+
+    table.add_row(str(rows), str(cols), str(total))
+
+    console.print(table)

pfc/commands/tail.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.tail(n), f"{session.file} (head {n})")

pfc/commands/unique.py

@@ -0,0 +1,44 @@
+from pfc.core.state import session
+from pfc.ui.table import render
+from rich.console import Console
+import pandas as pd
+
+console = Console()
+
+
+def run(args):
+    if session.df is None:
+        console.print("[red]No dataset loaded[/red]")
+        return
+
+    if not args:
+        console.print("[red]Usage:[/red] unique <column> [--count]")
+        return
+
+    df = session.df.df
+
+    show_count = False
+    if "--count" in args:
+        show_count = True
+        args.remove("--count")
+
+    col = " ".join(args)
+
+    if col not in df.columns:
+        console.print(f"[red]Invalid column:[/red] {col}")
+        console.print(f"[dim]Available columns:[/dim] {', '.join(df.columns)}")
+        return
+
+    if show_count:
+        vc = df[col].value_counts(dropna=False)
+        result = pd.DataFrame({
+            col: vc.index.astype(str),
+            "Count": vc.values
+        })
+        title = f"{session.file} (unique counts: {col})"
+    else:
+        uniques = df[col].drop_duplicates()
+        result = pd.DataFrame({col: uniques.astype(str).values})
+        title = f"{session.file} (unique: {col})"
+
+    render(result, title)

pfc/commands/value_counts.py

@@ -0,0 +1,42 @@
+from pfc.core.state import session
+from pfc.ui.table import render
+from rich.console import Console
+import pandas as pd
+
+console = Console()
+
+
+def run(args):
+    if session.df is None:
+        console.print("[red]No dataset loaded[/red]")
+        return
+
+    if not args:
+        console.print("[red]Usage:[/red] value_counts <column> [--normalize]")
+        return
+
+    df = session.df.df
+    normalize = False
+
+    if "--normalize" in args:
+        normalize = True
+        args.remove("--normalize")
+
+    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)
+
+    result = pd.DataFrame({
+        col: counts.index.astype(str),
+        "Count": counts.values
+    })
+
+    if normalize:
+        total = result["Count"].sum()
+        result["Percentage"] = (result["Count"] / total * 100).round(2)
+
+    render(result, f"{session.file} (value_counts: {col})")

pfc/core/dataset.py

@@ -0,0 +1,25 @@
+# pfc/core/dataset.py
+import pandas as pd
+
+class Dataset:
+    def __init__(self, path):
+        self.path = path
+        self.df = pd.read_csv(path)
+
+    def head(self, n=5):
+        return self.df.head(n).copy()
+
+    def tail(self, n=5):
+        return self.df.tail(n)
+
+    def columns(self):
+        return list(self.df.columns)
+
+    def describe(self):
+        return self.df.describe
+
+    def size(self):
+        return self.df.size
+
+    def index(self):
+        return self.df.index

pfc/core/state.py

@@ -0,0 +1,7 @@
+# pfc/core/state.py
+class Session:
+    def __init__(self):
+        self.df = None
+        self.file = None
+
+session = Session()

pfc/main.py

@@ -0,0 +1,14 @@
+# pfc/main.py
+# from pfc.shell.repl import start
+
+# if __name__ == "__main__":
+#     start()
+
+# pfc/main.py
+from pfc.shell.repl import start
+
+def main():
+    start()
+
+if __name__ == "__main__":
+    main()

pfc/shell/parser.py

@@ -0,0 +1,42 @@
+# pfc/shell/parser.py
+from pfc.commands import head, tail, cols, load, help, describe, size, index, info, select, value_counts, groupby, unique, barplot, histplot, lineplot, cls, heatmap
+
+COMMANDS = {
+    "help": help.run,
+    "cls": cls.run,
+
+    "load": load.run,
+
+    "head": head.run,
+    "tail": tail.run,
+    "cols": cols.run,
+
+    "describe": describe.run,
+    "size": size.run,
+
+    "index": index.run,
+
+    "info": info.run,
+
+    "select": select.run,
+
+    "value_counts": value_counts.run,
+
+    "groupby": groupby.run,
+
+    "unique": unique.run,
+
+    #--------------------------------Visualization Commands-----------------------------------------
+
+    "barplot": barplot.run,
+    "histplot": histplot.run,
+    "lineplot": lineplot.run,
+    "heatmap": heatmap.run
+
+}
+
+def dispatch(cmd, args):
+    if cmd in COMMANDS:
+        COMMANDS[cmd](args)
+    else:
+        print("❌ Unknown command")

pfc/shell/repl.py

@@ -0,0 +1,18 @@
+# pfc/shell/repl.py
+from pfc.shell.parser import dispatch
+
+def start():
+    print("pfc — Interactive Data Shell")
+    print("Load a dataset once and explore it using built-in commands.")
+    print("Type 'help' to see available commands. Type 'exit' to quit.\n")
+
+    while True:
+        raw = input("pfc> ").strip()
+        if not raw:
+            continue
+
+        if raw in {"exit", "quit"}:
+            break
+
+        parts = raw.split()
+        dispatch(parts[0], parts[1:])

pfc/ui/table.py

@@ -0,0 +1,106 @@
+# # pfc/ui/table.py
+# from rich.table import Table
+# from rich.console import Console
+
+# console = Console()
+
+# def render(df, title):
+#     table = Table(title=title, header_style="bold magenta", row_styles=["none", "dim"])
+#     for col in df.columns:
+#         table.add_column(col, max_width=20, overflow="ellipsis")
+
+#     for _, row in df.iterrows():
+#         table.add_row(*[str(v) for v in row])
+
+#     console.print(table)
+
+# from rich.console import Console
+# from rich.table import Table
+
+# console = Console()
+
+# MAX_VISIBLE_ROWS = 10
+
+
+# def render(df, title):
+#     table = Table(
+#         title=title,
+#         header_style="bold magenta",
+#         row_styles=["none", "dim"]
+#     )
+
+#     for col in df.columns:
+#         table.add_column(col, max_width=20, overflow="ellipsis")
+
+#     for _, row in df.iterrows():
+#         table.add_row(*[str(v) for v in row])
+
+#     # 🔥 Scroll if too many rows
+#     if len(df) > MAX_VISIBLE_ROWS:
+#         with console.pager():
+#             console.print(table)
+#     else:
+#         console.print(table)
+
+from rich.console import Console
+from rich.table import Table
+import os
+
+console = Console()
+MAX_VISIBLE_ROWS = 10
+
+
+def render(df, title):
+    rows = len(df)
+
+    # 🔵 Case 1: Small table → normal render
+    if rows <= MAX_VISIBLE_ROWS:
+        _print_table(df, title)
+        return
+
+    # 🔵 Case 2: Unix → pager
+    if os.name != "nt":
+        with console.pager():
+            _print_table(df, title)
+        return
+
+    # 🔵 Case 3: Windows → manual paging
+    _render_windows_paged(df, title)
+
+
+def _print_table(df, title):
+    table = Table(
+        title=title,
+        header_style="bold magenta",
+        row_styles=["none", "dim"],
+        show_lines=False
+    )
+
+    for col in df.columns:
+        table.add_column(col, max_width=20, overflow="ellipsis")
+
+    for _, row in df.iterrows():
+        table.add_row(*[str(v) for v in row])
+
+    console.print(table)
+
+
+def _render_windows_paged(df, title):
+    total = len(df)
+    start = 0
+
+    while start < total:
+        end = min(start + MAX_VISIBLE_ROWS, total)
+        chunk = df.iloc[start:end]
+
+        page_title = f"{title}  (rows {start + 1}-{end})"
+        _print_table(chunk, page_title)
+
+        start = end
+        if start >= total:
+            break
+
+        console.print("[dim]Press Enter for next page, q to quit[/dim]", end="")
+        choice = input().strip().lower()
+        if choice == "q":
+            break

pfc_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: pfc-cli
+Version: 0.1.0
+Summary: Terminal-first data exploration and visualization tool for CSV files
+Author-email: Shivam <shivamsharma22468@gmail.com>
+License: MIT
+Keywords: cli,data-analysis,eda,csv,terminal
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas
+Requires-Dist: numpy
+Requires-Dist: rich
+Dynamic: license-file
+
+# pfc (Pandas For CLI)
+
+pfc is a terminal-first data exploration and visualization tool for CSV files.
+It lets you analyze datasets interactively without leaving the terminal.
+
+## Features
+
+- Load CSV once and explore interactively
+- Head / tail / select / describe
+- Groupby, value_counts, unique
+- Terminal visualizations:
+  - barplot
+  - histogram
+  - lineplot
+  - heatmap
+- Works on Windows, Linux, macOS
+
+## Installation
+
+```bash
+pip install pfc-cli
+```

pfc_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,35 @@
+pfc/main.py,sha256=17lR2RLbFIB07HZQvzh1jEgg8NmOBrshAD_402_LgBA,205
+pfc/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pfc/commands/barplot.py,sha256=ADZbQzIqx6IShl3vycnRQInpPRmAQMCgZHHNJyjWBqA,1511
+pfc/commands/cls.py,sha256=anPj9Q16TSJeoS3ju2tRN1g4QqHSTL9AyIpzSNWB7yo,456
+pfc/commands/cols.py,sha256=d_LpWynJ5WahiWWEiGF0kuyHs5OefFKt7RcPCv2DSu8,486
+pfc/commands/describe.py,sha256=_gDErxD21k6vyxNA4DdeKu4cwup2BBHSs6Y6xD4ZTtA,3591
+pfc/commands/groupby.py,sha256=vIm1EkscbRL4nkNRIwXXi5D-et_BfDSRQK3PWT7O94k,1413
+pfc/commands/head.py,sha256=RQpHgUsMiqFT0nyPWZcqisFnBOQOueDuv965EJRI1rM,285
+pfc/commands/heatmap.py,sha256=sF_7gkiykbYmW2goOxRYVVhS70_niHwXXaZK2R1HyZI,2641
+pfc/commands/help.py,sha256=ZgFV1uDyjqVMfZ7tHWTlZHU8X672wfNidP3bGaASreY,3563
+pfc/commands/histplot.py,sha256=DOtGAaoViW9u3gjedX32vDLHVUK6Ekc9Ju8me5UgbLI,2129
+pfc/commands/index.py,sha256=ELZCCPI9782ekCIgFf6V0mT5jm98UOabqHVAEeQp2Gw,1188
+pfc/commands/info.py,sha256=MZb0rQ5880DTHgbe0DUArR_ul1CzhHZO0inxVG3tVz8,1582
+pfc/commands/lineplot.py,sha256=6J_UBoC1R0xltACkTm7DcMknVm_F_-OBDx6k_qs1VW4,2849
+pfc/commands/load.py,sha256=w-KfpU2WrQ7G7NoFq27ymUiC_UvOf4DGBdAhv16sZjk,511
+pfc/commands/select.py,sha256=ztosF3MH-YYepuM20AymaIblnWx0sz_xJbzHLOUQ-eY,985
+pfc/commands/size.py,sha256=sCqbdy5Oh4BZZQcTOB-ShGzNcwfs_9pzJ1Sef9Jf7EM,624
+pfc/commands/tail.py,sha256=viI-tbtqvXH5-sm5PpFRCpvLlQEXt7SC2GZmgPmGFPE,285
+pfc/commands/unique.py,sha256=28R4vex_ZRbdubL4p2C9OgbHqAC7jChmdq4m4hg5-FM,1132
+pfc/commands/value_counts.py,sha256=V1xu-PCNGQUVwbbvCMUqdKV49qk7TlblAjNZ-hK6zPw,979
+pfc/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pfc/core/dataset.py,sha256=KgIGUtObWiB7S9mK9sEOUHSxxDdK8doI9CftPFANiwc,488
+pfc/core/state.py,sha256=tVMcrWp7rJg3hNXiYY_Z2hFwwz-nXzOlwVuPt-sJcgU,128
+pfc/shell/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pfc/shell/parser.py,sha256=VUzE7JCJGvarDXSxEN8nwcbEmm5bDaEvtkgJtttSX10,902
+pfc/shell/repl.py,sha256=0T7_biAZ7uG23cgr_iQoaSaRBKHdwm2x1Ghn4tW7RK4,481
+pfc/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pfc/ui/styles.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pfc/ui/table.py,sha256=aXbT8-qb2LjFs57MxQtUg4UCOlHOixtlgChIyOcn7YY,2474
+pfc_cli-0.1.0.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pfc_cli-0.1.0.dist-info/METADATA,sha256=hq7wWAmyxR3IGORmzq7mgTXtw-9qu1JKhfIZk2A87cU,1054
+pfc_cli-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+pfc_cli-0.1.0.dist-info/entry_points.txt,sha256=Yz-2mCzaBKlmJfKHqu_LBuM4fuD9LB4rklIPK9oAGvU,39
+pfc_cli-0.1.0.dist-info/top_level.txt,sha256=n087vINEh-4CtgHhJqpOn2aUqJUxdnPoj-1LpiE7L3Y,4
+pfc_cli-0.1.0.dist-info/RECORD,,

pfc_cli-0.1.0.dist-info/WHEEL

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

pfc_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pfc = pfc.main:start

pfc_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pfc