oil-cli-tool 1.0.0__py3-none-any.whl

oil_cli_tool-1.0.0.dist-info/METADATA

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: oil-cli-tool
+Version: 1.0.0
+Summary: A tool for slick shell scripts.
+Author: Your Name
+Requires-Dist: typer
+Requires-Dist: inquirer
+Requires-Dist: yaspin
+Requires-Dist: tabulate
+Requires-Dist: pyfiglet
+Dynamic: author
+Dynamic: requires-dist
+Dynamic: summary

oil_cli_tool-1.0.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+oil_pkg/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+oil_pkg/cli.py,sha256=91m8bcgFBTciqj5_YdH2hEya7PGNVVY31LyoYAqKsS0,4482
+oil_pkg/core.py,sha256=MBTpxEnAVV2SjP9bUOz52NRa-rtlIKV7C_o00kN2PWw,2212
+oil_pkg/ui.py,sha256=6BFFBf8TlmPZxLl2aji21aB1poyWfcdk17_Ll4l6GRs,2192
+oil_cli_tool-1.0.0.dist-info/METADATA,sha256=TNY6N1aC_W57hm62llDrBwZA_yPTsdOYclzd74npDuM,286
+oil_cli_tool-1.0.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+oil_cli_tool-1.0.0.dist-info/entry_points.txt,sha256=ja3FkpHXN3OMGZRTU4r2gbvW1bMhLUv_fBVQziEe_A4,40
+oil_cli_tool-1.0.0.dist-info/top_level.txt,sha256=52UOC32rDJxVohGl3K4W9nArk6qM9HpBdiWCaAT_I4s,8
+oil_cli_tool-1.0.0.dist-info/RECORD,,

oil_cli_tool-1.0.0.dist-info/WHEEL

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

oil_cli_tool-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+oil = oil_pkg.cli:app

oil_cli_tool-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+oil_pkg

oil_pkg/cli.py

@@ -0,0 +1,151 @@
+from typing import List, Optional
+import typer
+from oil_pkg.core import oil_soak, oil_spill, oil_rag, oil_read_csv, oil_join, get_piped_data
+from oil_pkg.ui import oil_choose, oil_input, oil_spin, oil_splat, oil_confirm, oil_table, oil_write, oil_filter
+
+app = typer.Typer(
+    help="Oil: A tool for slick shell scripts.",
+    add_completion=False
+)
+
+@app.callback(invoke_without_command=True)
+def main(ctx: typer.Context):
+    """
+    Oil: A tool for slick shell scripts.
+    """
+    if ctx.invoked_subcommand is None:
+        typer.echo(ctx.get_help())
+        raise typer.Exit()
+
+@app.command()
+def choose(message: str, options: List[str] = typer.Argument(...)):
+    """Allows the user to select an option from a list."""
+    # List[str] automatically collects all positional arguments into a list [cite: 54, 75]
+    result = oil_choose(message, options)
+    typer.echo(result)
+
+@app.command()
+def input(message: str):
+    """Allows the user to input a string."""
+    result = oil_input(message)
+    typer.echo(result)
+
+@app.command()
+def soak(file_path: str, data: Optional[str] = typer.Argument(None)):
+    """Soaks up data and saves it to a persistent file."""
+    # If no data is provided as an argument, attempt to read from stdin (pipe)
+    if data is None:
+        piped_lines = get_piped_data()
+        data = "\n".join(piped_lines) if piped_lines else ""
+        
+    # Save the data to the user-specified file_path
+    oil_soak(file_path, {"cli_input": data})
+    typer.echo(f"✨ Successfully soaked data into {file_path}")
+
+@app.command()
+def spill(file_path: str):
+    """Spills (reads) data from a persistent file and prints it."""
+    result = oil_spill(file_path)
+    typer.echo(result)
+
+
+@app.command()
+def rag(file_path: str):
+    """Wipes a persistent state file clean."""
+    success = oil_rag(file_path)
+    if success:
+        typer.echo(f"✨ Wiped clean: {file_path}")
+    else:
+        typer.echo(f"Nothing to wipe: {file_path} does not exist.")
+
+@app.command()
+def spin(message: str, seconds: int = typer.Argument(2)):
+    """Displays a loading spinner."""
+    oil_spin(message, seconds)
+
+@app.command()
+def splat(text: str, font: str = "standard"):
+    """Generates ASCII art (splat) from text."""
+    # Use the function name defined in ui.py (oil_splat)
+    typer.echo(oil_splat(text, font=font))
+
+
+@app.command()
+def confirm(message: str):
+    """Ask a user to confirm an action."""
+    if oil_confirm(message):
+        typer.echo("Confirmed.")
+    else:
+        typer.echo("Action cancelled.")
+        raise typer.Exit(code=1)
+
+@app.command()
+def rag(file_path: str):
+    """Wipes a persistent state file clean."""
+    # Add the confirmation step
+    if not oil_confirm(f"Are you sure you want to wipe {file_path}?"):
+        typer.echo("Wipe aborted.")
+        raise typer.Exit()
+        
+    success = oil_rag(file_path)
+    if success:
+        typer.echo(f"✨ Wiped clean: {file_path}")
+    else:
+        typer.echo(f"Nothing to wipe: {file_path} does not exist.")
+
+@app.command()
+def table(file_path: str):
+    """Render a table of data from a file."""
+    # Assuming your spill function returns a list of lists or similar data structure
+    from oil.core import oil_spill
+    data = oil_spill(file_path)
+    typer.echo(oil_table(data))
+
+@app.command()
+def table(file_path: str):
+    """Render a table of data from a file."""
+    data = oil_read_csv(file_path)
+    # The first row is headers, the rest is data
+    typer.echo(oil_table(data, headers="firstrow"))
+
+@app.command()
+def join(file1: str, file2: str, mode: str = "vertical"):
+    """Join contents of two files."""
+    with open(file1, 'r') as f1, open(file2, 'r') as f2:
+        typer.echo(oil_join(f1.read(), f2.read(), mode))
+
+@app.command()
+def write(output_file: str = None):
+    """Prompt for long-form text using the system editor."""
+    content = oil_write()
+    if output_file:
+        with open(output_file, 'w') as f:
+            f.write(content)
+        typer.echo(f"✨ Content saved to {output_file}")
+    else:
+        typer.echo(content)
+
+
+
+@app.command()
+def filter(options: str = None):
+    """Filter input from a pipe or a comma-separated list."""
+    data = []
+    
+    if options:
+        data = options.split(',')
+    else:
+        data = get_piped_data()
+        
+    if not data:
+        typer.echo("No data provided to filter.")
+        raise typer.Exit()
+        
+    choice = oil_filter(data)
+    typer.echo(choice)
+
+
+
+if __name__ == "__main__":
+    app()
+

oil_pkg/core.py

@@ -0,0 +1,72 @@
+import json
+import os
+import csv
+import sys
+
+
+
+def oil_soak(file_path, data):
+    """Saves data to a user-defined file path."""
+    # Get the directory part of the path
+    directory = os.path.dirname(file_path)
+    
+    # Only try to create the directory if it's not the current directory
+    if directory:
+        os.makedirs(directory, exist_ok=True)
+    
+    with open(file_path, 'w') as f:
+        json.dump(data, f, indent=4)
+
+def oil_spill(file_path):
+    """Reads data from a user-defined file path."""
+    try:
+        with open(file_path, 'r') as f:
+            return json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError):
+        # Return an empty dict if the file is missing or corrupted
+        return {}
+
+def oil_rag(file_path):
+    """Wipes the persistent file clean (deletes it)."""
+    if os.path.exists(file_path):
+        os.remove(file_path)
+        return True
+    return False
+
+def oil_read_csv(file_path: str):
+    with open(file_path, mode='r', newline='') as f:
+        reader = csv.reader(f)
+        return list(reader)
+
+def oil_join(content1: str, content2: str, mode: str = "vertical"):
+    if mode == "vertical":
+        return f"{content1}\n{content2}"
+    elif mode == "horizontal":
+        lines1 = content1.splitlines()
+        lines2 = content2.splitlines()
+        # Ensure equal height for side-by-side
+        max_height = max(len(lines1), len(lines2))
+        lines1 += [""] * (max_height - len(lines1))
+        lines2 += [""] * (max_height - len(lines2))
+        
+        joined = [f"{l1:<30} {l2}" for l1, l2 in zip(lines1, lines2)]
+        return "\n".join(joined)
+    return content1
+
+
+def get_piped_data() -> list:
+    """Reads lines from stdin, then reconnects stdin to the terminal."""
+    if not sys.stdin.isatty():
+        # 1. Read the data coming from the pipe
+        data = sys.stdin.read().splitlines()
+        
+        # 2. Reconnect standard input to the controlling terminal
+        # This allows interactive prompts (like inquirer) to read keyboard input again
+        try:
+            sys.stdin = open('/dev/tty')
+        except OSError:
+            pass # Fallback if /dev/tty isn't available
+            
+        return data
+    return []
+

oil_pkg/ui.py

@@ -0,0 +1,78 @@
+import inquirer
+import typer
+import time
+import pyfiglet
+from yaspin import yaspin
+from tabulate import tabulate
+import click
+import os
+
+def oil_choose(message, options):
+    """Renders a pure UI menu from a list."""
+    questions = [
+        inquirer.List('choice', message=message, choices=options)
+    ]
+    answers = inquirer.prompt(questions)
+    
+    # Handle cancellation (Ctrl+C)
+    if answers is None:
+        return "Cancelled by user"
+        
+    return answers['choice']
+
+def oil_input(message):
+    """Captures pure UI input."""
+    return typer.prompt(message)
+
+def oil_spin(message, seconds=2):
+    """Pure UI: Displays a loading spinner for a set amount of time."""
+    with yaspin(text=message, color="cyan") as spinner:
+        time.sleep(seconds)
+        spinner.ok("✔")
+
+def oil_splat(text, font="standard"):
+    """Pure UI: Converts string into ASCII art."""
+    return pyfiglet.figlet_format(text, font=font)
+
+
+
+def oil_confirm(message: str) -> bool:
+    questions = [
+        inquirer.Confirm('confirmed', message=message, default=False),
+    ]
+    answers = inquirer.prompt(questions)
+    return answers['confirmed']  #
+
+# 
+
+def oil_table(data, headers="firstrow"):
+    return tabulate(data, headers=headers, tablefmt="grid")
+
+def oil_write(text: str = "") -> str:
+    """Opens the user's default editor to write/edit text."""
+    # click.edit() is the standard way to handle terminal editors
+    edited_text = click.edit(text)
+    return edited_text if edited_text is not None else ""
+
+def oil_filter(options: list) -> str:
+    """Provides an interactive fuzzy-selection interface."""
+    questions = [
+        inquirer.List('choice',
+                      message="Select an option",
+                      choices=options,
+                      carousel=True),
+    ]
+    
+    # --- THE OS-LEVEL FILE DESCRIPTOR SWAP ---
+    original_stdout_fd = os.dup(1)
+    
+    try:
+        tty_fd = os.open('/dev/tty', os.O_WRONLY)
+        os.dup2(tty_fd, 1)
+        answers = inquirer.prompt(questions)
+        os.close(tty_fd)
+    finally:
+        os.dup2(original_stdout_fd, 1)
+        os.close(original_stdout_fd)
+        
+    return answers['choice'] if answers else ""