pucit 0.1.0__py3-none-any.whl

pucit/__about__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

pucit/__init__.py

@@ -0,0 +1,3 @@
+from pucit.__about__ import __version__
+
+__all__ = ["__version__"]

pucit/__main__.py

@@ -0,0 +1,4 @@
+from pucit.cli import app
+
+if __name__ == "__main__":
+    app()

pucit/cli.py

@@ -0,0 +1,258 @@
+"""pucit — PUCIT student toolkit CLI."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import List, Optional
+
+import typer
+
+from pucit import __version__
+from pucit import cpp_build
+from pucit import docker_util as d
+from pucit.commands.bypass import bypass_app
+from pucit.commands.doctor import run_doctor, run_list
+from pucit.commands.install import install_app
+from pucit.commands.oracle import oracle_app
+from pucit.commands.scaffold import init_project, new_file
+from pucit.util import fail, first_existing, info, ok, run_cmd, run_streaming, which
+
+app = typer.Typer(
+    name="pucit",
+    help="PUCIT student toolkit — Oracle, PF/C++, bypass, and lab ease commands.",
+    no_args_is_help=True,
+    add_completion=False,
+)
+
+app.add_typer(install_app, name="install")
+app.add_typer(bypass_app, name="bypass")
+app.add_typer(oracle_app, name="oracle")
+
+
+def _oracle_target(target: str) -> None:
+    if target.lower() not in {"oracle", "db", "oracledb"}:
+        fail(f"Unknown target '{target}'. Try: oracle")
+        raise typer.Exit(1)
+
+
+@app.command("start")
+def start_cmd(target: str = typer.Argument(..., help="Service to start (oracle)")) -> None:
+    """Start a managed service: pucit start oracle"""
+    _oracle_target(target)
+    from pucit.commands.oracle import oracle_start
+
+    oracle_start()
+
+
+@app.command("stop")
+def stop_cmd(target: str = typer.Argument(..., help="Service to stop (oracle)")) -> None:
+    """Stop a managed service: pucit stop oracle"""
+    _oracle_target(target)
+    from pucit.commands.oracle import oracle_stop
+
+    oracle_stop()
+
+
+@app.command("status")
+def status_cmd(target: str = typer.Argument("oracle", help="Service (oracle)")) -> None:
+    """Show service status: pucit status oracle"""
+    _oracle_target(target)
+    from pucit.commands.oracle import oracle_status
+
+    oracle_status()
+
+
+@app.command("logs")
+def logs_cmd(
+    target: str = typer.Argument("oracle"),
+    follow: bool = typer.Option(False, "--follow", "-f"),
+    tail: int = typer.Option(100, "--tail"),
+) -> None:
+    """Show service logs: pucit logs oracle"""
+    _oracle_target(target)
+    from pucit.commands.oracle import oracle_logs
+
+    oracle_logs(follow=follow, tail=tail)
+
+
+@app.command("run")
+def run_cmd(
+    sources: Optional[List[str]] = typer.Argument(None, help="C++ sources (default: main.cpp)"),
+    flags: Optional[str] = typer.Option(None, "--flags", "-f", help='Extra flags e.g. "-O2"'),
+    std: Optional[str] = typer.Option(None, "--std", help="Language standard"),
+    out: Optional[str] = typer.Option(None, "--out", "-o", help="Output binary"),
+    input_file: Optional[str] = typer.Option(None, "--input", "-i", help="stdin from file"),
+) -> None:
+    """Compile and run: pucit run main.cpp"""
+    try:
+        code = cpp_build.execute_run(
+            list(sources or []),
+            flags=flags,
+            std=std,
+            out=out,
+            input_file=input_file,
+        )
+    except (FileNotFoundError, RuntimeError) as exc:
+        fail(str(exc))
+        raise typer.Exit(1) from exc
+    raise typer.Exit(code)
+
+
+@app.command("compile")
+def compile_cmd(
+    sources: Optional[List[str]] = typer.Argument(None),
+    flags: Optional[str] = typer.Option(None, "--flags", "-f"),
+    std: Optional[str] = typer.Option(None, "--std"),
+    out: Optional[str] = typer.Option(None, "--out", "-o"),
+) -> None:
+    """Compile only: pucit compile main.cpp"""
+    try:
+        code = cpp_build.execute_run(
+            list(sources or []),
+            flags=flags,
+            std=std,
+            out=out,
+            compile_only=True,
+        )
+    except (FileNotFoundError, RuntimeError) as exc:
+        fail(str(exc))
+        raise typer.Exit(1) from exc
+    raise typer.Exit(code)
+
+
+@app.command("debug")
+def debug_cmd(
+    sources: Optional[List[str]] = typer.Argument(None),
+    flags: Optional[str] = typer.Option(None, "--flags", "-f"),
+    std: Optional[str] = typer.Option(None, "--std"),
+    out: Optional[str] = typer.Option(None, "--out", "-o"),
+) -> None:
+    """Compile with -g and open gdb."""
+    try:
+        resolved = cpp_build.resolve_sources(list(sources or []))
+        code, binary, _ = cpp_build.compile_sources(
+            resolved, out=out, flags=flags, std=std, debug=True
+        )
+    except (FileNotFoundError, RuntimeError) as exc:
+        fail(str(exc))
+        raise typer.Exit(1) from exc
+    if code != 0:
+        raise typer.Exit(code)
+    gdb = which("gdb")
+    if not gdb:
+        fail("gdb not found. Run: pucit install pf")
+        raise typer.Exit(1)
+    info(f"Starting gdb on {binary}")
+    raise typer.Exit(run_streaming([gdb, str(binary)]))
+
+
+@app.command("watch")
+def watch_cmd(
+    sources: Optional[List[str]] = typer.Argument(None),
+    flags: Optional[str] = typer.Option(None, "--flags", "-f"),
+    std: Optional[str] = typer.Option(None, "--std"),
+    out: Optional[str] = typer.Option(None, "--out", "-o"),
+    input_file: Optional[str] = typer.Option(None, "--input", "-i"),
+) -> None:
+    """Recompile + run on file change."""
+    try:
+        code = cpp_build.watch_run(
+            list(sources or []),
+            flags=flags,
+            std=std,
+            out=out,
+            input_file=input_file,
+        )
+    except (FileNotFoundError, RuntimeError) as exc:
+        fail(str(exc))
+        raise typer.Exit(1) from exc
+    raise typer.Exit(code)
+
+
+@app.command("clean")
+def clean_cmd() -> None:
+    """Remove build/ and a.out in the current directory."""
+    removed = cpp_build.clean_artifacts()
+    if not removed:
+        info("Nothing to clean")
+    else:
+        for path in removed:
+            ok(f"Removed {path}")
+
+
+@app.command("new")
+def new_cmd(
+    name: str = typer.Argument(..., help="File or stem, e.g. hello or hello.cpp"),
+    force: bool = typer.Option(False, "--force", "-f"),
+) -> None:
+    """Create a new C++ file from template."""
+    new_file(name, force=force)
+
+
+@app.command("init")
+def init_cmd(force: bool = typer.Option(False, "--force", "-f")) -> None:
+    """Scaffold a PF lab folder (main.cpp, Makefile, .gitignore)."""
+    init_project(force=force)
+
+
+@app.command("doctor")
+def doctor_cmd() -> None:
+    """Check compilers, Docker, Oracle, bypass, and friends."""
+    raise typer.Exit(run_doctor())
+
+
+@app.command("list")
+def list_cmd() -> None:
+    """List managed components and their status."""
+    raise typer.Exit(run_list())
+
+
+@app.command("version")
+def version_cmd() -> None:
+    """Show pucit version."""
+    typer.echo(__version__)
+
+
+@app.command("which")
+def which_cmd(tool: str = typer.Argument(..., help="Tool name, e.g. g++ or docker")) -> None:
+    """Show resolved path for a tool."""
+    # allow g++ style
+    path = which(tool) or first_existing((tool,))
+    if not path and tool in {"g++", "cxx", "compiler"}:
+        path = cpp_build.find_compiler()
+    if not path and tool == "docker":
+        path = d.docker_bin()
+    if path:
+        typer.echo(path)
+    else:
+        fail(f"{tool} not found")
+        raise typer.Exit(1)
+
+
+@app.command("open")
+def open_cmd(path: str = typer.Argument(".", help="Path to open")) -> None:
+    """Open a folder/file in VS Code, Cursor, or the file manager."""
+    target = Path(path).resolve()
+    editors = ("cursor", "code", "codium")
+    for editor in editors:
+        binary = which(editor)
+        if binary:
+            raise typer.Exit(run_cmd([binary, str(target)]).returncode)
+    # fallback file manager / start
+    import sys
+
+    if sys.platform.startswith("win"):
+        raise typer.Exit(run_cmd(["explorer", str(target)]).returncode)
+    opener = which("xdg-open")
+    if opener:
+        raise typer.Exit(run_cmd([opener, str(target)]).returncode)
+    fail("No editor or file manager found")
+    raise typer.Exit(1)
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()

pucit/commands/__init__.py

@@ -0,0 +1 @@
+"""Command modules for the pucit CLI."""

pucit/commands/bypass.py

@@ -0,0 +1,55 @@
+"""Campus proxy via bypass-pucit."""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from typing import Optional
+
+import typer
+
+from pucit import config as cfg
+from pucit.util import fail, info, ok, which
+
+bypass_app = typer.Typer(help="Campus internet bypass (wraps bypass-pucit).")
+
+
+def _bypass_argv() -> list:
+    binary = which("bypass_pucit")
+    if binary:
+        return [binary]
+    # fallback: python -m bypass_pucit
+    return [shutil.which("python3") or shutil.which("python") or "python3", "-m", "bypass_pucit"]
+
+
+@bypass_app.command("set")
+def bypass_set(
+    proxy: Optional[str] = typer.Option(
+        None, "--proxy", "-p", help="Proxy URL (default from config / bypass-pucit)"
+    ),
+) -> None:
+    """Apply campus proxy settings via bypass_pucit."""
+    argv = _bypass_argv() + ["set"]
+    proxy_url = proxy or str(cfg.get("proxy"))
+    if proxy_url:
+        argv.extend(["--proxy", proxy_url])
+    info(" ".join(argv))
+    result = subprocess.run(argv)
+    if result.returncode == 0:
+        ok("Proxy applied")
+    else:
+        fail("bypass_pucit set failed")
+    raise typer.Exit(result.returncode)
+
+
+@bypass_app.command("unset")
+def bypass_unset() -> None:
+    """Remove campus proxy settings."""
+    argv = _bypass_argv() + ["unset"]
+    info(" ".join(argv))
+    result = subprocess.run(argv)
+    if result.returncode == 0:
+        ok("Proxy removed")
+    else:
+        fail("bypass_pucit unset failed")
+    raise typer.Exit(result.returncode)

pucit/commands/doctor.py

@@ -0,0 +1,80 @@
+"""Environment doctor and component listing."""
+
+from __future__ import annotations
+
+import platform
+import sys
+
+import typer
+from rich.table import Table
+
+from pucit import __version__
+from pucit import docker_util as d
+from pucit.cpp_build import find_compiler
+from pucit.util import console, which
+
+doctor_app = typer.Typer(help="Health checks (also available as top-level pucit doctor).")
+
+
+def _row(table: Table, name: str, ok: bool, detail: str) -> None:
+    mark = "[green]ok[/green]" if ok else "[red]missing[/red]"
+    table.add_row(name, mark, detail)
+
+
+def run_doctor() -> int:
+    table = Table(title=f"pucit doctor (v{__version__})")
+    table.add_column("Check")
+    table.add_column("Status")
+    table.add_column("Detail")
+
+    _row(table, "OS", True, f"{platform.system()} {platform.release()} ({platform.machine()})")
+    _row(table, "Python", True, sys.version.split()[0])
+
+    compiler = find_compiler()
+    _row(table, "C++ compiler", bool(compiler), compiler or "run: pucit install pf")
+    _row(table, "make", bool(which("make")), which("make") or "—")
+    _row(table, "gdb", bool(which("gdb")), which("gdb") or "—")
+    _row(table, "cmake", bool(which("cmake")), which("cmake") or "—")
+
+    docker = d.docker_bin()
+    docker_ok = bool(docker) and d.docker_available()
+    detail = docker or "run: pucit install docker"
+    if docker and not d.docker_available():
+        detail = f"{docker} found but daemon not usable"
+    _row(table, "Docker", docker_ok, detail)
+
+    name = d.container_name()
+    if docker_ok and d.container_exists(name):
+        state = "running" if d.container_running(name) else "stopped"
+        _row(table, "Oracle container", True, f"{name} ({state})")
+    else:
+        _row(table, "Oracle container", False, "run: pucit install oracle")
+
+    bypass = which("bypass_pucit")
+    _row(table, "bypass_pucit", bool(bypass), bypass or "pip install bypass-pucit")
+
+    sqlplus = which("sqlplus")
+    _row(table, "sqlplus", bool(sqlplus), sqlplus or "optional: pucit install sqlclient")
+
+    console.print(table)
+    return 0
+
+
+def run_list() -> int:
+    table = Table(title="pucit managed components")
+    table.add_column("Component")
+    table.add_column("Status")
+
+    compiler = find_compiler()
+    table.add_row("pf / C++", "ready" if compiler else "not installed")
+    docker_ok = bool(d.docker_bin()) and d.docker_available()
+    table.add_row("docker", "ready" if docker_ok else "not ready")
+    name = d.container_name()
+    if docker_ok and d.container_exists(name):
+        table.add_row("oracle", "running" if d.container_running(name) else "stopped")
+    else:
+        table.add_row("oracle", "not installed")
+    table.add_row("bypass_pucit", "ready" if which("bypass_pucit") else "not installed")
+    table.add_row("sqlplus", "ready" if which("sqlplus") else "not installed")
+    console.print(table)
+    return 0

pucit/commands/install.py

@@ -0,0 +1,83 @@
+"""Install subcommands: oracle, pf, docker, sqlclient."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+
+from pucit.commands.oracle import oracle_install
+from pucit.platform import PackageError, docker_packages, install_packages, pf_packages
+from pucit.util import detect_pkg_manager, fail, info, is_windows, ok, run_cmd, which
+
+install_app = typer.Typer(help="Install toolchains and services.")
+
+
+@install_app.command("oracle")
+def install_oracle(
+    password: Optional[str] = typer.Option(None, "--password", "-p"),
+    pull_only: bool = typer.Option(False, "--pull-only"),
+) -> None:
+    """Install Oracle Free via Docker."""
+    oracle_install(password=password, pull_only=pull_only)
+
+
+@install_app.command("pf")
+def install_pf() -> None:
+    """Install Programming Fundamentals C++ essentials."""
+    try:
+        code = install_packages(pf_packages(), title="PF / C++ essentials")
+    except PackageError as exc:
+        fail(str(exc))
+        raise typer.Exit(1) from exc
+    if which("g++") or which("clang++"):
+        ok(f"Compiler: {which('g++') or which('clang++')}")
+    else:
+        info("Packages installed; open a new shell if g++ is still not on PATH.")
+    raise typer.Exit(code)
+
+
+@install_app.command("docker")
+def install_docker() -> None:
+    """Install Docker Engine / Docker Desktop."""
+    try:
+        code = install_packages(docker_packages(), title="Docker")
+    except PackageError as exc:
+        fail(str(exc))
+        raise typer.Exit(1) from exc
+    if is_windows():
+        info("Start Docker Desktop from the Start menu, then re-open your terminal.")
+    else:
+        if which("systemctl"):
+            run_cmd(["sudo", "systemctl", "enable", "--now", "docker"], capture=True)
+            info("If needed, add yourself to the docker group: sudo usermod -aG docker $USER")
+    raise typer.Exit(code)
+
+
+@install_app.command("sqlclient")
+def install_sqlclient() -> None:
+    """Install or guide Oracle Instant Client / sqlplus."""
+    if which("sqlplus"):
+        ok(f"sqlplus already present: {which('sqlplus')}")
+        return
+
+    if is_windows():
+        info("Windows: download Instant Client (Basic + SQL*Plus) from Oracle:")
+        info("  https://www.oracle.com/database/technologies/instant-client/downloads.html")
+        info("Add the unzipped folder to PATH, then reopen the terminal.")
+        raise typer.Exit(0)
+
+    manager = detect_pkg_manager()
+    pkgs = ["oracle-instantclient-sqlplus"] if manager == "dnf" else []
+    if pkgs:
+        try:
+            code = install_packages(pkgs, title="Oracle SQL*Plus")
+            raise typer.Exit(code)
+        except PackageError:
+            pass
+
+    info("sqlplus is not in your distro repos by default.")
+    info("Download Instant Client Basic + SQL*Plus RPMs/ZIPs from:")
+    info("  https://www.oracle.com/database/technologies/instant-client/linux-x86-64-downloads.html")
+    info("Then: sudo alien/rpm install or unzip and export LD_LIBRARY_PATH + PATH.")
+    raise typer.Exit(0)

pucit/commands/oracle.py

@@ -0,0 +1,176 @@
+"""Oracle Database Free via Docker."""
+
+from __future__ import annotations
+
+import os
+from typing import Optional
+
+import typer
+
+from pucit import docker_util as d
+from pucit.platform import PackageError, docker_packages, install_packages
+from pucit.util import fail, info, ok, run_cmd, warn
+
+oracle_app = typer.Typer(help="Manage the local Oracle Free container.")
+
+
+@oracle_app.command("install")
+def oracle_install(
+    password: Optional[str] = typer.Option(
+        None, "--password", "-p", help="ORACLE_PWD (generated if omitted)"
+    ),
+    pull_only: bool = typer.Option(False, "--pull-only", help="Only pull the image"),
+) -> None:
+    """Install (pull + create) Oracle Free Docker container."""
+    if not d.docker_bin():
+        warn("Docker not found — trying to install it first")
+        try:
+            code = install_packages(docker_packages(), title="docker")
+        except PackageError as exc:
+            fail(str(exc))
+            raise typer.Exit(1) from exc
+        if code != 0:
+            raise typer.Exit(code)
+
+    if not d.docker_available():
+        fail("Docker is installed but not usable. Start the Docker daemon/Desktop and retry.")
+        raise typer.Exit(1)
+
+    info(f"Pulling {d.oracle_image()} …")
+    success, output = d.pull_image()
+    if not success:
+        fail("Image pull failed.")
+        if "unauthorized" in output.lower() or "denied" in output.lower() or "login" in output.lower():
+            info("Oracle Container Registry may require login / license accept:")
+            info("  1) Visit https://container-registry.oracle.com/ and accept the Database Free terms")
+            info("  2) docker login container-registry.oracle.com")
+            info("  3) pucit install oracle")
+        else:
+            print(output)
+        raise typer.Exit(1)
+    ok("Image ready")
+
+    if pull_only:
+        return
+
+    name = d.container_name()
+    if d.container_exists(name):
+        ok(f"Container '{name}' already exists. Use: pucit start oracle")
+        d.print_connect_info()
+        return
+
+    pwd = password or os.environ.get("PUCIT_ORACLE_PWD") or d.load_oracle_password() or d.generate_password()
+    d.save_oracle_password(pwd)
+    argv = d.build_run_argv(pwd, name)
+    display = [a.replace(f"ORACLE_PWD={pwd}", "ORACLE_PWD=***") for a in argv]
+    info(" ".join(display))
+    result = run_cmd(argv, capture=True)
+    if result.returncode != 0:
+        fail((result.stderr or result.stdout or "docker run failed").strip())
+        raise typer.Exit(result.returncode)
+    ok(f"Created container '{name}'")
+    info("Oracle may take 1–2 minutes to become ready. Check: pucit status oracle")
+    d.print_connect_info(pwd)
+
+
+@oracle_app.command("start")
+def oracle_start() -> None:
+    """Start the Oracle container."""
+    name = d.container_name()
+    if not d.container_exists(name):
+        fail(f"Container '{name}' not found. Run: pucit install oracle")
+        raise typer.Exit(1)
+    if d.container_running(name):
+        ok(f"'{name}' is already running")
+        return
+    result = run_cmd(d.docker_argv("start", name), capture=True)
+    if result.returncode != 0:
+        fail((result.stderr or "start failed").strip())
+        raise typer.Exit(result.returncode)
+    ok(f"Started '{name}'")
+
+
+@oracle_app.command("stop")
+def oracle_stop() -> None:
+    """Stop the Oracle container."""
+    name = d.container_name()
+    if not d.container_exists(name):
+        fail(f"Container '{name}' not found")
+        raise typer.Exit(1)
+    result = run_cmd(d.docker_argv("stop", name), capture=True)
+    if result.returncode != 0:
+        fail((result.stderr or "stop failed").strip())
+        raise typer.Exit(result.returncode)
+    ok(f"Stopped '{name}'")
+
+
+@oracle_app.command("status")
+def oracle_status() -> None:
+    """Show Oracle container status."""
+    name = d.container_name()
+    if not d.docker_bin():
+        fail("Docker/Podman not found")
+        raise typer.Exit(1)
+    if not d.container_exists(name):
+        warn(f"Container '{name}' is not installed")
+        raise typer.Exit(1)
+    state = "running" if d.container_running(name) else "stopped"
+    ok(f"{name}: {state}")
+    d.print_connect_info()
+
+
+@oracle_app.command("logs")
+def oracle_logs(
+    follow: bool = typer.Option(False, "--follow", "-f", help="Follow log output"),
+    tail: int = typer.Option(100, "--tail", help="Lines to show"),
+) -> None:
+    """Show Oracle container logs."""
+    name = d.container_name()
+    argv = d.docker_argv("logs", "--tail", str(tail))
+    if follow:
+        argv.append("-f")
+    argv.append(name)
+    raise typer.Exit(run_cmd(argv).returncode)
+
+
+@oracle_app.command("rm")
+def oracle_rm(
+    volumes: bool = typer.Option(False, "--volumes", "-v", help="Also remove data volume"),
+    force: bool = typer.Option(False, "--force", "-f", help="Force remove"),
+) -> None:
+    """Remove the Oracle container."""
+    name = d.container_name()
+    if not d.container_exists(name):
+        warn(f"Container '{name}' not found")
+        return
+    argv = d.docker_argv("rm")
+    if force:
+        argv.append("-f")
+    if volumes:
+        argv.append("-v")
+    argv.append(name)
+    result = run_cmd(argv, capture=True)
+    if result.returncode != 0:
+        fail((result.stderr or "rm failed").strip())
+        raise typer.Exit(result.returncode)
+    ok(f"Removed '{name}'")
+
+
+@oracle_app.command("connect")
+def oracle_connect(
+    launch: bool = typer.Option(False, "--launch", "-l", help="Launch sqlplus if available"),
+) -> None:
+    """Print (or launch) a sqlplus connection."""
+    from pucit.util import which
+
+    d.print_connect_info()
+    if not launch:
+        return
+    sqlplus = which("sqlplus")
+    if not sqlplus:
+        fail("sqlplus not found. Try: pucit install sqlclient")
+        raise typer.Exit(1)
+    pwd = d.load_oracle_password() or "oracle"
+    port = d.oracle_port()
+    conn = f"system/{pwd}@//localhost:{port}/FREEPDB1"
+    raise typer.Exit(run_cmd([sqlplus, conn]).returncode)