chatsee-redact 0.2.0__py3-none-any.whl

chatsee_redact/__init__.py

@@ -0,0 +1,35 @@
+"""chatsee-redact: local JSON/JSONL log redaction using ChatSee's rules.
+
+Redaction runs entirely on your machine. The only network call is a read-only
+fetch of the regex classifiers; your log content is never transmitted.
+"""
+from chatsee_redact.files import (
+    REDACT_ALL,
+    detect_format,
+    fields_to_redact,
+    redact_csv_file,
+    redact_file,
+    redact_json_file,
+    redact_jsonl_file,
+)
+from chatsee_redact.rules import (
+    build_classifiers_url,
+    fetch_raw_classifiers,
+    fetch_rules,
+)
+
+__version__ = "0.2.0"
+
+__all__ = [
+    "redact_file",
+    "redact_json_file",
+    "redact_jsonl_file",
+    "redact_csv_file",
+    "fields_to_redact",
+    "detect_format",
+    "REDACT_ALL",
+    "build_classifiers_url",
+    "fetch_rules",
+    "fetch_raw_classifiers",
+    "__version__",
+]

chatsee_redact/cli.py

@@ -0,0 +1,262 @@
+"""Command-line entry point: ``chatsee-redact``.
+
+Two modes:
+  chatsee-redact <files...> [opts]   redact JSON/JSONL/CSV files (default)
+  chatsee-redact dump-rules [opts]   fetch + print/export the raw rules
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import os
+import sys
+from typing import List, Optional
+
+from chatsee_redact import __version__
+from chatsee_redact.files import fields_to_redact, redact_file
+from chatsee_redact.rules import (
+    build_classifiers_url,
+    fetch_raw_classifiers,
+    fetch_rules,
+)
+
+logger = logging.getLogger("chatsee_redact")
+
+
+def _add_rule_source_args(p: argparse.ArgumentParser) -> None:
+    p.add_argument(
+        "--env",
+        default="qa",
+        help="ChatSee environment for the rule source: dev|qa|demo|poc "
+        "(default: qa). Ignored if --classifiers-url is given.",
+    )
+    p.add_argument(
+        "--classifiers-url",
+        help="Full URL of the classifiers endpoint (overrides --env).",
+    )
+    p.add_argument(
+        "--timeout",
+        type=float,
+        default=5.0,
+        help="Rule-fetch HTTP timeout in seconds (default: 5).",
+    )
+    p.add_argument(
+        "--no-verify-ssl",
+        action="store_true",
+        help="Disable TLS certificate verification for the rule fetch.",
+    )
+
+
+def _resolve_output(
+    in_path: str, out_dir: Optional[str], out_file: Optional[str]
+) -> str:
+    if out_file:
+        return out_file
+    if out_dir:
+        os.makedirs(out_dir, exist_ok=True)
+        return os.path.join(out_dir, os.path.basename(in_path))
+    stem, ext = os.path.splitext(in_path)
+    return f"{stem}.redacted{ext}"
+
+
+def build_redact_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="chatsee-redact",
+        description=(
+            "Redact PII in your own JSON/JSONL/CSV files locally, using "
+            "ChatSee's redaction rules. Your file content never leaves this "
+            "machine; the only network call is a read-only fetch of the regex "
+            "rules. Use 'chatsee-redact dump-rules' to inspect those rules."
+        ),
+    )
+    p.add_argument("inputs", nargs="+", help="Input JSON, JSONL or CSV file(s).")
+    p.add_argument(
+        "-o",
+        "--out",
+        metavar="DIR",
+        help="Output directory (created if missing). Default: write "
+        "'<name>.redacted.<ext>' next to each input.",
+    )
+    p.add_argument(
+        "--out-file",
+        metavar="PATH",
+        help="Explicit output path (only valid with a single input).",
+    )
+    _add_rule_source_args(p)
+    p.add_argument(
+        "--fields",
+        metavar="A,B,C",
+        help="Comma-separated keys/columns to redact. Default: redact every "
+        "string value, recursively.",
+    )
+    p.add_argument(
+        "--format",
+        choices=["auto", "json", "jsonl", "csv"],
+        default="auto",
+        help="Input format. 'auto' uses the extension (.jsonl/.ndjson -> "
+        "jsonl, .json -> json, .csv -> csv, else jsonl).",
+    )
+    p.add_argument(
+        "--indent",
+        type=int,
+        default=2,
+        help="Indent for JSON output (default: 2). Use -1 for compact output.",
+    )
+    p.add_argument(
+        "--cache-ttl",
+        type=int,
+        default=300,
+        help="In-process rule cache TTL in seconds (default: 300).",
+    )
+    p.add_argument(
+        "--strict",
+        action="store_true",
+        help="Abort (write nothing) if no redaction rules could be fetched, "
+        "instead of copying unredacted (the default fail-open behaviour).",
+    )
+    p.add_argument(
+        "-q", "--quiet", action="store_true", help="Only log warnings and errors."
+    )
+    p.add_argument(
+        "--version", action="version", version=f"chatsee-redact {__version__}"
+    )
+    return p
+
+
+def build_dump_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="chatsee-redact dump-rules",
+        description=(
+            "Fetch the raw redaction classifier documents (as the API serves "
+            "them) so you can audit exactly which regex patterns run. Prints "
+            "to stdout unless -o/--out-file is given."
+        ),
+    )
+    _add_rule_source_args(p)
+    p.add_argument(
+        "-o",
+        "--out-file",
+        metavar="PATH",
+        help="Write the rules JSON here instead of stdout.",
+    )
+    p.add_argument(
+        "--indent",
+        type=int,
+        default=2,
+        help="Indent for the rules JSON (default: 2). Use -1 for compact.",
+    )
+    p.add_argument(
+        "-q", "--quiet", action="store_true", help="Only log warnings and errors."
+    )
+    return p
+
+
+def _dump_rules_main(argv: Optional[List[str]]) -> int:
+    args = build_dump_parser().parse_args(argv)
+    logging.basicConfig(
+        level=logging.WARNING if args.quiet else logging.INFO,
+        format="%(levelname)s %(message)s",
+    )
+    try:
+        url, docs = fetch_raw_classifiers(
+            env=args.env,
+            classifiers_url=args.classifiers_url,
+            timeout_seconds=args.timeout,
+            verify_ssl=not args.no_verify_ssl,
+        )
+    except Exception as exc:  # noqa: BLE001 — report any fetch/parse failure
+        logger.error("Failed to fetch classifiers: %s", exc)
+        return 1
+
+    indent = None if args.indent < 0 else args.indent
+    text = json.dumps(docs, ensure_ascii=False, indent=indent)
+    if args.out_file:
+        tmp = args.out_file + ".tmp"
+        with open(tmp, "w", encoding="utf-8") as fh:
+            fh.write(text)
+        os.replace(tmp, args.out_file)
+        logger.info(
+            "Wrote %d classifier(s) from %s -> %s", len(docs), url, args.out_file
+        )
+    else:
+        logger.info("Fetched %d classifier(s) from %s", len(docs), url)
+        print(text)
+    return 0
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    argv = list(sys.argv[1:] if argv is None else argv)
+    if argv and argv[0] == "dump-rules":
+        return _dump_rules_main(argv[1:])
+    return _redact_main(argv)
+
+
+def _redact_main(argv: Optional[List[str]]) -> int:
+    args = build_redact_parser().parse_args(argv)
+    logging.basicConfig(
+        level=logging.WARNING if args.quiet else logging.INFO,
+        format="%(levelname)s %(message)s",
+    )
+
+    if args.out_file and len(args.inputs) != 1:
+        logger.error("--out-file can only be used with exactly one input file.")
+        return 2
+
+    fields = fields_to_redact(args.fields.split(",") if args.fields else None)
+    indent = None if args.indent < 0 else args.indent
+
+    url = build_classifiers_url(args.env, args.classifiers_url)
+    logger.info("Fetching redaction rules from %s", url)
+    _, rules = fetch_rules(
+        env=args.env,
+        classifiers_url=args.classifiers_url,
+        cache_ttl_seconds=args.cache_ttl,
+        timeout_seconds=args.timeout,
+        verify_ssl=not args.no_verify_ssl,
+    )
+
+    if not rules:
+        if args.strict:
+            logger.error(
+                "No redaction rules available from %s and --strict is set. "
+                "Aborting without writing any output.",
+                url,
+            )
+            return 3
+        logger.warning(
+            "!! No redaction rules available from %s. Output will be an "
+            "UNREDACTED copy (fail-open). Re-run with --strict to abort instead.",
+            url,
+        )
+    else:
+        logger.info("Loaded %d redaction rule(s).", len(rules))
+
+    exit_code = 0
+    for in_path in args.inputs:
+        if not os.path.isfile(in_path):
+            logger.error("Input not found: %s", in_path)
+            exit_code = 2
+            continue
+        out_path = _resolve_output(in_path, args.out, args.out_file)
+        if os.path.abspath(out_path) == os.path.abspath(in_path):
+            logger.error("Refusing to overwrite the source file: %s", in_path)
+            exit_code = 2
+            continue
+        try:
+            fmt, n = redact_file(
+                in_path, out_path, rules, fields, fmt=args.format, indent=indent
+            )
+        except (OSError, ValueError) as exc:
+            logger.error("Failed to redact %s: %s", in_path, exc)
+            exit_code = 1
+            continue
+        logger.info(
+            "Redacted %s (%s, %d record(s)) -> %s", in_path, fmt, n, out_path
+        )
+
+    return exit_code
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

chatsee_redact/files.py

@@ -0,0 +1,173 @@
+"""
+File-level redaction adapters.
+
+These functions are pure and offline-testable: they take an already-compiled
+list of ``RedactionRule`` objects and never touch the network. Fetching the
+rules (the single outbound call this tool makes) lives in :mod:`rules`.
+
+The actual masking is delegated to the ChatSee SDK's engine
+(``chatsee.redaction.redact_payload_sync``) so redaction here is byte-for-byte
+identical to what the ChatSee pipeline applies. We only add the JSON/JSONL
+file plumbing on top.
+"""
+from __future__ import annotations
+
+import csv
+import json
+import os
+from typing import List, Optional, Tuple, Union
+
+from chatsee.redaction import RedactionRule, redact_payload_sync
+
+# Sentinel understood by the engine: "redact every string value, recursively".
+REDACT_ALL = "*"
+
+_JSONL_EXTS = {".jsonl", ".ndjson"}
+_JSON_EXTS = {".json"}
+_CSV_EXTS = {".csv"}
+
+FieldsArg = Union[str, List[str]]
+
+
+def fields_to_redact(fields: Optional[List[str]]) -> FieldsArg:
+    """Map a ``--fields`` list (or ``None``) to the engine's argument.
+
+    - ``None`` / empty  -> ``"*"`` (redact every string value, recursively)
+    - ``["a", "b"]``    -> redact only those top-level keys
+    """
+    cleaned = [f.strip() for f in (fields or []) if f and f.strip()]
+    return cleaned or REDACT_ALL
+
+
+def detect_format(path: str, override: Optional[str] = None) -> str:
+    """Resolve the input format to ``"json"``, ``"jsonl"`` or ``"csv"``.
+
+    With ``override`` unset (or ``"auto"``), the file extension decides:
+    ``.jsonl``/``.ndjson`` -> jsonl, ``.json`` -> json, ``.csv`` -> csv,
+    anything else -> jsonl (log files are usually line-delimited JSON).
+    """
+    if override and override != "auto":
+        return override
+    ext = os.path.splitext(path)[1].lower()
+    if ext in _JSONL_EXTS:
+        return "jsonl"
+    if ext in _JSON_EXTS:
+        return "json"
+    if ext in _CSV_EXTS:
+        return "csv"
+    return "jsonl"
+
+
+def _atomic_write_text(out_path: str, text: str) -> None:
+    """Write ``text`` to ``out_path`` via a temp file + atomic replace, so a
+    crash mid-write never leaves a half-written 'redacted' file behind."""
+    tmp = out_path + ".tmp"
+    with open(tmp, "w", encoding="utf-8") as fh:
+        fh.write(text)
+    os.replace(tmp, out_path)
+
+
+def redact_json_file(
+    in_path: str,
+    out_path: str,
+    rules: List[RedactionRule],
+    fields: FieldsArg = REDACT_ALL,
+    indent: Optional[int] = 2,
+) -> int:
+    """Redact a whole-document JSON file (array, object, or scalar).
+
+    Returns the number of top-level records (``len`` for a list, else ``1``).
+    """
+    # utf-8-sig tolerates (and strips) a leading BOM, common in files
+    # authored on Windows; plain utf-8 input is unaffected.
+    with open(in_path, "r", encoding="utf-8-sig") as fh:
+        data = json.load(fh)
+
+    redacted = redact_payload_sync(data, rules, fields_to_redact=fields)
+
+    _atomic_write_text(
+        out_path, json.dumps(redacted, ensure_ascii=False, indent=indent)
+    )
+    return len(redacted) if isinstance(redacted, list) else 1
+
+
+def redact_jsonl_file(
+    in_path: str,
+    out_path: str,
+    rules: List[RedactionRule],
+    fields: FieldsArg = REDACT_ALL,
+) -> int:
+    """Redact a JSON Lines file, streaming one record per line.
+
+    Never loads the whole file into memory. Blank lines are preserved.
+    Returns the number of JSON records redacted.
+    """
+    count = 0
+    tmp = out_path + ".tmp"
+    with open(in_path, "r", encoding="utf-8-sig") as src, open(
+        tmp, "w", encoding="utf-8"
+    ) as dst:
+        for line in src:
+            stripped = line.strip()
+            if not stripped:
+                dst.write("\n")
+                continue
+            record = json.loads(stripped)
+            redacted = redact_payload_sync(record, rules, fields_to_redact=fields)
+            dst.write(json.dumps(redacted, ensure_ascii=False) + "\n")
+            count += 1
+    os.replace(tmp, out_path)
+    return count
+
+
+def redact_csv_file(
+    in_path: str,
+    out_path: str,
+    rules: List[RedactionRule],
+    fields: FieldsArg = REDACT_ALL,
+) -> int:
+    """Redact a CSV file, streaming row by row. The header is preserved.
+
+    With ``fields == "*"`` every cell is scanned; with a list of column names
+    only those columns are redacted. Returns the number of data rows written.
+    """
+    count = 0
+    tmp = out_path + ".tmp"
+    with open(in_path, "r", encoding="utf-8-sig", newline="") as src, open(
+        tmp, "w", encoding="utf-8", newline=""
+    ) as dst:
+        reader = csv.DictReader(src)
+        if reader.fieldnames is None:  # empty input
+            os.replace(tmp, out_path)
+            return 0
+        # extrasaction="ignore" guards against ragged rows with extra columns.
+        writer = csv.DictWriter(
+            dst, fieldnames=reader.fieldnames, extrasaction="ignore"
+        )
+        writer.writeheader()
+        for row in reader:
+            redacted = redact_payload_sync(dict(row), rules, fields_to_redact=fields)
+            writer.writerow(redacted)
+            count += 1
+    os.replace(tmp, out_path)
+    return count
+
+
+def redact_file(
+    in_path: str,
+    out_path: str,
+    rules: List[RedactionRule],
+    fields: FieldsArg = REDACT_ALL,
+    fmt: Optional[str] = None,
+    indent: Optional[int] = 2,
+) -> Tuple[str, int]:
+    """Dispatch to the JSON, JSONL or CSV adapter based on the detected format.
+
+    Returns ``(resolved_format, record_count)``.
+    """
+    resolved = detect_format(in_path, fmt)
+    if resolved == "csv":
+        return "csv", redact_csv_file(in_path, out_path, rules, fields)
+    if resolved == "jsonl":
+        return "jsonl", redact_jsonl_file(in_path, out_path, rules, fields)
+    return "json", redact_json_file(in_path, out_path, rules, fields, indent)

chatsee_redact/rules.py

@@ -0,0 +1,84 @@
+"""
+Redaction-rule fetching.
+
+This is the ONLY part of the tool that touches the network, and it is a
+read-only pull of the regex classifiers from ChatSee. No log content is ever
+sent. Rule loading + the in-process TTL cache + fail-open behaviour are reused
+verbatim from the ChatSee SDK.
+"""
+from __future__ import annotations
+
+from typing import Any, List, Optional, Tuple
+
+import requests
+
+from chatsee.env import resolve_api_base_url
+from chatsee.redaction import RedactionRule, load_redaction_rules_sync
+
+CLASSIFIERS_PATH = "/v1/redaction/fetch_classifiers"
+
+
+def build_classifiers_url(
+    env: Optional[str] = None, classifiers_url: Optional[str] = None
+) -> str:
+    """Resolve the classifiers endpoint.
+
+    ``classifiers_url`` (a full URL) wins; otherwise the environment alias
+    (``dev``/``qa``/``demo``/``poc`` or a full base URL) is resolved via the
+    SDK and the standard redaction path is appended.
+    """
+    if classifiers_url:
+        return classifiers_url
+    base = resolve_api_base_url(env).rstrip("/")
+    return f"{base}{CLASSIFIERS_PATH}"
+
+
+def fetch_rules(
+    env: Optional[str] = None,
+    classifiers_url: Optional[str] = None,
+    cache_ttl_seconds: int = 300,
+    timeout_seconds: float = 5.0,
+    verify_ssl: bool = True,
+) -> Tuple[str, List[RedactionRule]]:
+    """Fetch + compile the redaction rules. Returns ``(url, rules)``.
+
+    Fails open: on any fetch/parse error the SDK loader returns ``[]`` and we
+    propagate that (the caller decides whether to warn-and-copy or abort).
+    """
+    url = build_classifiers_url(env, classifiers_url)
+    rules = load_redaction_rules_sync(
+        classifiers_url=url,
+        cache_ttl_seconds=cache_ttl_seconds,
+        timeout_seconds=timeout_seconds,
+        verify_ssl=verify_ssl,
+    )
+    return url, rules
+
+
+def fetch_raw_classifiers(
+    env: Optional[str] = None,
+    classifiers_url: Optional[str] = None,
+    timeout_seconds: float = 5.0,
+    verify_ssl: bool = True,
+) -> Tuple[str, List[Any]]:
+    """Fetch the raw classifier documents exactly as the API serves them, for
+    inspection/export (``dump-rules``). Returns ``(url, docs)``.
+
+    Unlike :func:`fetch_rules`, this returns the un-compiled JSON docs (regex
+    as a string, etc.) so a human can audit precisely which patterns run.
+    Raises on HTTP/parse errors (the caller reports them).
+    """
+    url = build_classifiers_url(env, classifiers_url)
+    resp = requests.post(
+        url,
+        json={},
+        timeout=timeout_seconds,
+        verify=verify_ssl,
+        headers={"accept": "application/json", "content-type": "application/json"},
+    )
+    resp.raise_for_status()
+    payload = resp.json()
+    docs = payload.get("data", []) if isinstance(payload, dict) else []
+    if not isinstance(docs, list):
+        docs = []
+    return url, docs

chatsee_redact-0.2.0.dist-info/METADATA

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: chatsee-redact
+Version: 0.2.0
+Summary: Local JSON/JSONL/CSV log redaction using ChatSee's redaction rules.
+Maintainer: ChatSee
+Maintainer-email: contact@chatsee.ai
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: chatsee-ai>=0.9.5
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: maintainer
+Dynamic: maintainer-email
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# chatsee-redact
+
+Redact PII in your own **JSON / JSONL / CSV log files** locally, using ChatSee's
+redaction rules.
+
+**Your log content never leaves your machine.** The only network call this
+tool makes is a *read-only* fetch of the regex classifier rules from ChatSee.
+The raw and redacted content is read from, and written to, local files only —
+there is no telemetry and nothing is uploaded.
+
+Because it reuses the exact redaction engine shipped in the ChatSee SDK, the
+masking you get here is identical to what the ChatSee pipeline would apply.
+
+## Install
+
+```bash
+pip install chatsee-redact
+```
+
+This pulls in `chatsee-ai` (the SDK), whose base install depends only on
+`requests`.
+
+## Usage
+
+```bash
+# Redact one file; writes ./redacted/app.json
+chatsee-redact app.json --out ./redacted/
+
+# Default output is alongside the input: app.redacted.json
+chatsee-redact app.json
+
+# Multiple files into one folder
+chatsee-redact logs/*.jsonl --out ./redacted/
+
+# Pick the environment whose rules to use (default: qa)
+chatsee-redact app.json --env demo --out ./redacted/
+```
+
+Input → output:
+
+```
+app.json          -->  ./redacted/app.json      (all string values masked)
+```
+
+## What gets redacted
+
+By default **every string value** in the document is scanned and masked
+(recursively, through nested objects and arrays). Non-string values
+(numbers, booleans, null) are left untouched.
+
+To restrict redaction to specific top-level keys:
+
+```bash
+chatsee-redact app.json --fields user_message,bot_message,email
+```
+
+## Formats
+
+| Input | Handling |
+|-------|----------|
+| `.json`            | Whole-document: JSON array, object, or scalar. |
+| `.jsonl` / `.ndjson` | JSON Lines — streamed one record per line (safe for large logs). |
+| `.csv`             | Per-row, streamed; header preserved. `--fields` selects columns. |
+| other extension    | Treated as JSONL. Override with `--format`. |
+
+Force a format with `--format {auto,json,jsonl,csv}`.
+
+## Inspecting the rules (`dump-rules`)
+
+Fetch the raw classifier documents (the exact regexes that will run) so they
+can be audited before you trust the tool:
+
+```bash
+chatsee-redact dump-rules --env qa            # prints the rules JSON to stdout
+chatsee-redact dump-rules --env qa -o rules.json
+```
+
+## Options
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `-o, --out DIR`      | alongside input | Output directory (created if missing). |
+| `--out-file PATH`    | —       | Explicit output path (single input only). |
+| `--env`              | `qa`    | Rule source environment: `dev`/`qa`/`demo`/`poc`. |
+| `--classifiers-url`  | —       | Full classifiers URL (overrides `--env`). |
+| `--fields A,B,C`     | all strings | Restrict redaction to these top-level keys / CSV columns. |
+| `--format`           | `auto`  | `auto` \| `json` \| `jsonl` \| `csv`. |
+| `--indent N`         | `2`     | JSON output indent (`-1` = compact). |
+| `--timeout`          | `5`     | Rule-fetch HTTP timeout (seconds). |
+| `--cache-ttl`        | `300`   | In-process rule cache TTL (seconds). |
+| `--no-verify-ssl`    | off     | Disable TLS verification for the rule fetch. |
+| `--strict`           | off     | Abort (write nothing) if no rules could be fetched, instead of copying unredacted. |
+| `-q, --quiet`        | off     | Only log warnings/errors. |
+
+## Behaviour when rules can't be fetched
+
+By default the tool **fails open** (matching the SDK): it warns loudly and
+writes an *unredacted* copy so a transient outage doesn't break your job. Pass
+`--strict` to instead **abort and write nothing** — recommended when the output
+must be guaranteed redacted.
+
+## Exit codes
+
+| Code | Meaning |
+|------|---------|
+| `0`  | Success. |
+| `1`  | One or more files failed to redact (I/O or parse error). |
+| `2`  | Bad invocation (missing input, refused source overwrite, `--out-file` with multiple inputs). |
+| `3`  | `--strict` and no rules available. |

chatsee_redact-0.2.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+chatsee_redact/__init__.py,sha256=xSv59TLRxew_sM7e2MLJrrzqvAllli2ee_pa5f49X-0,800
+chatsee_redact/cli.py,sha256=e0BNlecGL2KK8Qavs4Zuy3AIGkofZ9O5QJehXENdUZE,8379
+chatsee_redact/files.py,sha256=wBwKptat1CFx0CPSeGtrcf3X_-TMn1hyQxuwFLCh3TU,5764
+chatsee_redact/rules.py,sha256=2L_G4OkL0ksm7MVdWd2lPHgrNIx-zur-0O78CVEqY0g,2813
+chatsee_redact-0.2.0.dist-info/METADATA,sha256=RliR8SK8qPkdIRR08pxLV-uUBG-msEcqjEJcCjMHiLY,4674
+chatsee_redact-0.2.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+chatsee_redact-0.2.0.dist-info/entry_points.txt,sha256=Ey36XbOA96d0XIY_Z4GeAk9t8FOdX2zCYD_0WUzRmPM,59
+chatsee_redact-0.2.0.dist-info/top_level.txt,sha256=SBakjZGCAsBFtxE36aGhW3maOC5qZsL6Q-K9D4vUqlE,15
+chatsee_redact-0.2.0.dist-info/RECORD,,

chatsee_redact-0.2.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
+

chatsee_redact-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+chatsee-redact = chatsee_redact.cli:main

chatsee_redact-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+chatsee_redact