nophi-ui 0.1.0__tar.gz

nophi_ui-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 no-phi contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

nophi_ui-0.1.0/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: nophi-ui
+Version: 0.1.0
+Summary: Local web review interface for nophi / nophi-av PHI redaction
+License: MIT
+Project-URL: Homepage, https://github.com/kshen3778/no-phi
+Project-URL: Repository, https://github.com/kshen3778/no-phi
+Keywords: phi,pii,redaction,review,ui
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: nophi>=0.1
+Requires-Dist: nophi-av>=0.1
+Requires-Dist: fastapi>=0.110
+Requires-Dist: uvicorn[standard]>=0.29
+Requires-Dist: python-multipart>=0.0.9
+Dynamic: license-file
+
+# nophi-ui
+
+A local web review interface for the [`nophi`](../nophi) (documents) and
+[`nophi-av`](../nophi-av) (audio/video) PHI redaction engines.
+
+It is a thin FastAPI frontend — the redaction logic stays in the two engines.
+It lets you run detection from the browser, **remove false-positive detections**
+(and, for audio, add a missed segment by hand) before redaction is applied, and
+view the redacted result.
+
+## Run
+
+```bash
+nophi-ui            # opens http://127.0.0.1:8000
+nophi-ui --port 9000 --no-open
+```
+
+You type a server-side **input directory** and **output directory** (raw paths),
+preview the files that will be processed, then start detection.
+
+## What it does
+
+- **Documents** (`.txt .csv .docx .xlsx .pdf`): detect → review the detection
+  list → uncheck false positives → apply. PDF previews inline; docx/xlsx are
+  download-only.
+- **Audio**: detect → review (play the original clip per detection) → uncheck
+  false positives and/or add missed `start/end` segments → apply (re-scrubs from
+  the original; no re-transcription).
+- **Video**: view-only. Redacted in one shot; detections shown for reference.
+
+## Security
+
+This tool serves PHI, so by design it:
+
+- binds to **`127.0.0.1` only** (refuses other hosts),
+- locks **CORS** to its own origin,
+- requires a **per-launch token** on every API call,
+- serves files by **opaque job/file id** (never a client-supplied path),
+- marks PHI responses **`Cache-Control: no-store`** and serves only the clipped
+  segment for audio review.
+
+State is held **in memory** for the process lifetime; closing the server clears
+it (a restart means re-running detection).

nophi_ui-0.1.0/README.md

@@ -0,0 +1,43 @@
+# nophi-ui
+
+A local web review interface for the [`nophi`](../nophi) (documents) and
+[`nophi-av`](../nophi-av) (audio/video) PHI redaction engines.
+
+It is a thin FastAPI frontend — the redaction logic stays in the two engines.
+It lets you run detection from the browser, **remove false-positive detections**
+(and, for audio, add a missed segment by hand) before redaction is applied, and
+view the redacted result.
+
+## Run
+
+```bash
+nophi-ui            # opens http://127.0.0.1:8000
+nophi-ui --port 9000 --no-open
+```
+
+You type a server-side **input directory** and **output directory** (raw paths),
+preview the files that will be processed, then start detection.
+
+## What it does
+
+- **Documents** (`.txt .csv .docx .xlsx .pdf`): detect → review the detection
+  list → uncheck false positives → apply. PDF previews inline; docx/xlsx are
+  download-only.
+- **Audio**: detect → review (play the original clip per detection) → uncheck
+  false positives and/or add missed `start/end` segments → apply (re-scrubs from
+  the original; no re-transcription).
+- **Video**: view-only. Redacted in one shot; detections shown for reference.
+
+## Security
+
+This tool serves PHI, so by design it:
+
+- binds to **`127.0.0.1` only** (refuses other hosts),
+- locks **CORS** to its own origin,
+- requires a **per-launch token** on every API call,
+- serves files by **opaque job/file id** (never a client-supplied path),
+- marks PHI responses **`Cache-Control: no-store`** and serves only the clipped
+  segment for audio review.
+
+State is held **in memory** for the process lifetime; closing the server clears
+it (a restart means re-running detection).

nophi_ui-0.1.0/nophi_ui/__init__.py

@@ -0,0 +1,10 @@
+"""Local web review interface for nophi / nophi-av PHI redaction.
+
+A thin FastAPI frontend over the two redaction engines. The redaction logic
+lives in ``nophi`` (documents) and ``nophi_av`` (audio/video); this package only
+routes files to the right engine, normalizes findings for the browser, runs
+detection as a background job, and lets the user remove false-positive detections
+before redaction is applied.
+"""
+
+__version__ = "0.1.0"

nophi_ui-0.1.0/nophi_ui/__main__.py

@@ -0,0 +1,48 @@
+# `nophi-ui` entry point: mint a per-launch token, build the app, and serve it on
+# loopback only. The user opens the printed URL; the page picks up the token and
+# every API call carries it.
+from __future__ import annotations
+
+import argparse
+import secrets
+import threading
+import webbrowser
+
+import uvicorn
+
+from nophi_ui.logconf import configure, log
+from nophi_ui.server import create_app
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(prog="nophi-ui", description="Local PHI redaction review UI")
+    parser.add_argument("--host", default="127.0.0.1", help="Bind host (default 127.0.0.1; loopback only)")
+    parser.add_argument("--port", type=int, default=8000, help="Bind port (default 8000)")
+    parser.add_argument("--no-open", action="store_true", help="Do not open a browser automatically")
+    parser.add_argument("--log-level", default="info", help="Console log level: debug, info, warning, error")
+    args = parser.parse_args()
+
+    configure(args.log_level)
+
+    if args.host not in ("127.0.0.1", "localhost", "::1"):
+        print(f"⚠  Refusing to bind to {args.host!r}: nophi-ui serves PHI and must stay on loopback.")
+        print("   Use 127.0.0.1 (the default).")
+        raise SystemExit(2)
+
+    token = secrets.token_urlsafe(24)
+    origins = [f"http://127.0.0.1:{args.port}", f"http://localhost:{args.port}"]
+    app = create_app(token, origins)
+
+    url = f"http://127.0.0.1:{args.port}/"
+    print(f"\n  nophi-ui → {url}")
+    print("  (loopback only; close this process to stop and clear all in-memory state)\n")
+    log.info(f"serving on {url} (loopback only)")
+
+    if not args.no_open:
+        threading.Timer(1.0, lambda: webbrowser.open(url)).start()
+
+    uvicorn.run(app, host=args.host, port=args.port, log_level="warning")
+
+
+if __name__ == "__main__":
+    main()

nophi_ui-0.1.0/nophi_ui/api.py

@@ -0,0 +1,228 @@
+# HTTP API for the review UI. JSON endpoints for the scan/review/apply flow plus
+# file-serving endpoints (redacted result, original audio clip, report). All
+# routes are mounted under /api and protected by the startup-token middleware in
+# server.py. PHI responses are marked no-store.
+from __future__ import annotations
+
+import os
+import tempfile
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+from starlette.background import BackgroundTask
+
+from nophi_av.audio import clip_segment
+
+from nophi_ui import engines, jobs, folderpicker
+from nophi_ui.logconf import log
+
+router = APIRouter(prefix="/api")
+
+_NO_STORE = {"Cache-Control": "no-store"}
+
+
+# ── Request models ───────────────────────────────────────────────────────────
+class PreviewReq(BaseModel):
+    input_dir: str
+
+
+class JobReq(BaseModel):
+    input_dir: str
+    output_dir: str
+    settings: dict = {}
+
+
+class AddedInterval(BaseModel):
+    entity_type: str = "MANUAL"
+    start_time: float
+    end_time: float
+
+
+class ApplyReq(BaseModel):
+    removed: list[int] = []
+    added: list[AddedInterval] = []
+
+
+# ── Helpers ──────────────────────────────────────────────────────────────────
+def _dir(path_str: str, *, must_exist: bool) -> Path:
+    p = Path(path_str).expanduser()
+    if must_exist and not p.is_dir():
+        raise HTTPException(400, f"Not a directory: {p}")
+    return p
+
+
+def _get_job(job_id: str) -> jobs.Job:
+    job = jobs.JOBS.get(job_id)
+    if job is None:
+        raise HTTPException(404, "job not found")
+    return job
+
+
+def _get_file(job_id: str, file_id: str):
+    job = _get_job(job_id)
+    fe = next((f for f in job.files if f.file_id == file_id), None)
+    if fe is None:
+        raise HTTPException(404, "file not found")
+    return job, fe
+
+
+def _findings_view(fe) -> list[dict]:
+    """Strip the heavy raw engine finding before sending to the browser."""
+    return [{k: v for k, v in f.items() if k != "raw"} for f in fe.findings]
+
+
+# ── Endpoints ────────────────────────────────────────────────────────────────
+@router.get("/capabilities")
+async def capabilities():
+    return {"folder_picker": folderpicker.available()}
+
+
+@router.get("/pick-folder")
+def pick_folder():
+    """Open the native folder chooser on the server's machine (blocks until the
+    user picks or cancels). Returns {"path": <abs path>|null}."""
+    if not folderpicker.available():
+        raise HTTPException(404, "no native folder picker on this platform")
+    return {"path": folderpicker.pick_folder()}
+
+
+@router.post("/preview")
+async def preview(req: PreviewReq):
+    input_dir = _dir(req.input_dir, must_exist=True)
+    out = []
+    for p in engines.collect_files(input_dir):
+        out.append({
+            "name": str(p.relative_to(input_dir)),
+            "kind": engines.classify(p),
+            "ext": p.suffix.lower(),
+        })
+    return {"input_dir": str(input_dir), "files": out}
+
+
+@router.post("/jobs")
+async def start_job(req: JobReq):
+    if not req.input_dir.strip():
+        raise HTTPException(400, "Input directory is required")
+    if not req.output_dir.strip():
+        raise HTTPException(400, "Output directory is required")
+    input_dir = _dir(req.input_dir, must_exist=True)
+    output_dir = _dir(req.output_dir, must_exist=False)
+    if not engines.collect_files(input_dir):
+        raise HTTPException(400, "No supported files found in input directory")
+    job = jobs.create_job(input_dir, output_dir, req.settings)
+    return {"job_id": job.job_id}
+
+
+@router.get("/jobs/{job_id}")
+async def job_status(job_id: str):
+    job = _get_job(job_id)
+    return {
+        "job_id": job.job_id,
+        "state": job.state,
+        "error": job.error,
+        "output_dir": str(job.output_dir),
+        "files": [
+            {
+                "file_id": fe.file_id,
+                "name": fe.rel,
+                "kind": fe.kind,
+                "ext": fe.ext,
+                "state": fe.state,
+                "status": fe.status,
+                "error": fe.error,
+                "n_findings": len([f for f in fe.findings if not f.get("removed")]),
+                "viewable": fe.viewable,
+                "output_name": fe.output_name,
+                "progress": fe.progress,
+            }
+            for fe in job.files
+        ],
+    }
+
+
+@router.delete("/jobs/{job_id}")
+async def cancel_job(job_id: str):
+    """Drop a job from the registry (Cancel run). Any in-flight detection thread
+    keeps running to completion on its own copy but its results are discarded."""
+    jobs.JOBS.pop(job_id, None)
+    log.info(f"run cancelled — job {job_id}")
+    return {"ok": True}
+
+
+@router.get("/jobs/{job_id}/files/{file_id}")
+async def file_detail(job_id: str, file_id: str):
+    _job, fe = _get_file(job_id, file_id)
+    return {
+        "file_id": fe.file_id,
+        "name": fe.rel,
+        "kind": fe.kind,
+        "ext": fe.ext,
+        "state": fe.state,
+        "viewable": fe.viewable,
+        "inline": fe.ext in engines.INLINE_VIEWABLE,
+        "output_name": fe.output_name,
+        "output_path": str(fe.output_path) if fe.output_path else None,
+        "findings": _findings_view(fe),
+    }
+
+
+@router.post("/jobs/{job_id}/files/{file_id}/apply")
+def apply(job_id: str, file_id: str, req: ApplyReq):
+    job, fe = _get_file(job_id, file_id)
+    if fe.kind == "video":
+        raise HTTPException(400, "Video files are view-only")
+    if fe.state not in ("ready", "applied"):
+        raise HTTPException(409, f"file is not ready (state={fe.state})")
+    try:
+        jobs.apply_file(job, fe, set(req.removed), [a.model_dump() for a in req.added])
+    except Exception as exc:
+        fe.state = "error"
+        fe.error = str(exc)
+        log.warning(f"apply failed — {fe.rel}: {exc}")
+        log.debug("traceback", exc_info=True)
+        raise HTTPException(500, f"apply failed: {exc}")
+    return {"ok": True, "output_name": fe.output_name, "viewable": fe.viewable}
+
+
+@router.get("/jobs/{job_id}/files/{file_id}/result")
+def result(job_id: str, file_id: str):
+    _job, fe = _get_file(job_id, file_id)
+    if not fe.output_path or not Path(fe.output_path).exists():
+        raise HTTPException(404, "no redacted result yet")
+    # Inline so the PDF/audio/video renders in the page instead of downloading
+    # (the file is already saved to the output dir; this endpoint is just a preview).
+    return FileResponse(
+        str(fe.output_path), filename=fe.output_name,
+        headers=_NO_STORE, content_disposition_type="inline",
+    )
+
+
+@router.get("/jobs/{job_id}/files/{file_id}/clip")
+def clip(job_id: str, file_id: str, start: float, end: float):
+    _job, fe = _get_file(job_id, file_id)
+    if fe.kind != "audio":
+        raise HTTPException(400, "clips are only available for audio files")
+    fd, name = tempfile.mkstemp(suffix=".mp3", prefix="nophi_clip_")
+    os.close(fd)  # we only need the path; don't leak the descriptor
+    tmp = Path(name)
+    try:
+        clip_segment(fe.path, start, end, tmp)
+    except Exception:
+        tmp.unlink(missing_ok=True)  # don't leave the temp file behind on failure
+        raise
+    return FileResponse(
+        str(tmp), media_type="audio/mpeg", headers=_NO_STORE,
+        background=BackgroundTask(lambda: tmp.unlink(missing_ok=True)),
+    )
+
+
+@router.get("/jobs/{job_id}/report")
+def report(job_id: str, kind: str = "doc"):
+    job = _get_job(job_id)
+    name = "phi_report.xlsx" if kind == "doc" else "phi_av_report.xlsx"
+    path = job.output_dir / name
+    if not path.exists():
+        raise HTTPException(404, "report not generated yet")
+    return FileResponse(str(path), filename=name, headers=_NO_STORE)

nophi_ui-0.1.0/nophi_ui/engines.py

@@ -0,0 +1,134 @@
+# Routing + normalization glue between the web layer and the two redaction
+# engines. NO redaction logic lives here — it dispatches to nophi's document
+# handlers (detect_*/apply_*) and nophi_av's audio detect/apply, and converts the
+# two finding schemas (document char offsets vs audio time intervals) into one
+# shape the frontend renders.
+from __future__ import annotations
+
+from pathlib import Path
+
+from nophi_av.pipeline import AUDIO_EXTENSIONS, VIDEO_EXTENSIONS
+
+from nophi.handlers.text import detect_text, detect_csv, apply_text, apply_csv
+from nophi.handlers.docx import detect_docx, apply_docx, write_docx
+from nophi.handlers.xlsx import detect_xlsx, apply_xlsx, write_xlsx
+from nophi.handlers.pdf import detect_pdf, apply_pdf, write_pdf
+
+DOCUMENT_EXTENSIONS = {".txt", ".csv", ".docx", ".xlsx", ".pdf"}
+SUPPORTED_EXTENSIONS = DOCUMENT_EXTENSIONS | AUDIO_EXTENSIONS | VIDEO_EXTENSIONS
+
+# Formats the browser can render the redacted result for inline; the rest are
+# download-only (docx, xlsx).
+INLINE_VIEWABLE = {".pdf"} | AUDIO_EXTENSIONS | VIDEO_EXTENSIONS
+
+
+def classify(path: Path) -> str | None:
+    """Return 'document' | 'audio' | 'video', or None if unsupported."""
+    ext = path.suffix.lower()
+    if ext in DOCUMENT_EXTENSIONS:
+        return "document"
+    if ext in AUDIO_EXTENSIONS:
+        return "audio"
+    if ext in VIDEO_EXTENSIONS:
+        return "video"
+    return None
+
+
+def collect_files(input_dir: Path) -> list[Path]:
+    """Supported files under input_dir (recursive), skipping hidden/junk paths."""
+    files: list[Path] = []
+    for f in sorted(input_dir.rglob("*")):
+        if (
+            f.is_file()
+            and not f.name.startswith(".")
+            and "__pycache__" not in f.parts
+            and ".git" not in f.parts
+            and f.suffix.lower() in SUPPORTED_EXTENSIONS
+        ):
+            files.append(f)
+    return files
+
+
+# ── Document detect / apply dispatch ─────────────────────────────────────────
+def detect_document(path: Path, analyzer, entities, exclude) -> list[dict]:
+    ext = path.suffix.lower()
+    if ext == ".txt":
+        return detect_text(path, analyzer, entities, exclude)
+    if ext == ".csv":
+        return detect_csv(path, analyzer, entities, exclude)
+    if ext == ".docx":
+        return detect_docx(path, analyzer, entities, exclude)
+    if ext == ".xlsx":
+        return detect_xlsx(path, analyzer, entities, exclude)
+    if ext == ".pdf":
+        return detect_pdf(path, analyzer, entities, exclude)
+    raise ValueError(f"Unsupported document type: {ext}")
+
+
+def apply_document(path: Path, findings, output_path: Path, anonymizer, operators) -> None:
+    ext = path.suffix.lower()
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    if ext == ".txt":
+        output_path.write_text(apply_text(path, findings, anonymizer, operators), encoding="utf-8")
+    elif ext == ".csv":
+        output_path.write_text(apply_csv(path, findings, anonymizer, operators), encoding="utf-8")
+    elif ext == ".docx":
+        write_docx(apply_docx(path, findings, anonymizer, operators), output_path)
+    elif ext == ".xlsx":
+        write_xlsx(apply_xlsx(path, findings, anonymizer, operators), output_path)
+    elif ext == ".pdf":
+        write_pdf(apply_pdf(path, findings, operators), output_path)
+    else:
+        raise ValueError(f"Unsupported document type: {ext}")
+
+
+# ── Finding normalization for the frontend ───────────────────────────────────
+def _position_label(unit: dict) -> str:
+    """Human-readable location of a document finding for the review table."""
+    kind = unit.get("kind")
+    if kind == "text":
+        return "text"
+    if kind == "csv":
+        return f"row {unit['row'] + 1}, col {unit['col'] + 1}"
+    if kind == "docx_para":
+        return f"paragraph {unit['index'] + 1}"
+    if kind == "xlsx_cell":
+        return f"{unit['sheet']}!{unit['coord']}"
+    if kind == "pdf_page":
+        return f"page {unit['page'] + 1}"
+    return ""
+
+
+def normalize(finding: dict, kind: str, index: int) -> dict:
+    """Project an engine finding into the shape the frontend table consumes.
+
+    The raw engine finding is kept verbatim under ``raw`` so apply can rebuild the
+    exact survivor list; the top-level keys are display-only.
+    """
+    common = {
+        "fid": index,
+        "entity_type": finding.get("entity_type"),
+        "original_text": finding.get("original_text"),
+        "replacement": finding.get("replacement"),
+        "context": finding.get("context", ""),
+        "removed": False,
+        "added": False,
+        "raw": finding,
+    }
+    if kind == "audio":
+        common["start_time"] = finding.get("start_time")
+        common["end_time"] = finding.get("end_time")
+        common["speaker"] = finding.get("speaker")
+        common["scrubbable"] = (
+            finding.get("start_time") is not None and finding.get("end_time") is not None
+        )
+        common["position"] = _fmt_interval(finding.get("start_time"), finding.get("end_time"))
+    else:
+        common["position"] = _position_label(finding.get("unit", {}))
+    return common
+
+
+def _fmt_interval(start, end) -> str:
+    if start is None or end is None:
+        return "—"
+    return f"{float(start):.2f}s – {float(end):.2f}s"

nophi_ui-0.1.0/nophi_ui/folderpicker.py

@@ -0,0 +1,55 @@
+# Native folder chooser for the input/output fields. The server runs on the
+# user's own machine, so it shells out to the OS picker and returns the chosen
+# absolute path. We shell out (rather than use tkinter) so the dialog runs in its
+# own process — no main-thread/display constraints on our side, safe to call from
+# a worker thread.
+#
+# Supported: macOS (osascript) and Windows (PowerShell FolderBrowserDialog).
+# Elsewhere the picker is unavailable and the UI falls back to the typed field.
+from __future__ import annotations
+
+import subprocess
+import sys
+from typing import Optional
+
+
+def available() -> bool:
+    return sys.platform in ("darwin", "win32")
+
+
+def pick_folder() -> Optional[str]:
+    """Open the native folder chooser; return the chosen path, or None if the
+    user cancelled (or the platform has no picker)."""
+    if sys.platform == "darwin":
+        return _pick_macos()
+    if sys.platform == "win32":
+        return _pick_windows()
+    return None
+
+
+def _pick_macos() -> Optional[str]:
+    script = 'POSIX path of (choose folder with prompt "Select a folder")'
+    proc = subprocess.run(["osascript", "-e", script], capture_output=True, text=True)
+    if proc.returncode != 0:  # user cancelled -> "User canceled. (-128)"
+        return None
+    path = proc.stdout.strip()
+    if len(path) > 1:
+        path = path.rstrip("/")  # drop osascript's trailing slash (keep root "/")
+    return path or None
+
+
+def _pick_windows() -> Optional[str]:
+    # -STA is required by FolderBrowserDialog (single-threaded apartment).
+    ps = (
+        "Add-Type -AssemblyName System.Windows.Forms; "
+        "$d = New-Object System.Windows.Forms.FolderBrowserDialog; "
+        "if ($d.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) "
+        "{ Write-Output $d.SelectedPath }"
+    )
+    proc = subprocess.run(
+        ["powershell", "-NoProfile", "-STA", "-Command", ps],
+        capture_output=True, text=True,
+    )
+    if proc.returncode != 0:
+        return None
+    return proc.stdout.strip() or None