sys2txt 0.1.1__py3-none-any.whl

sys2txt/__init__.py

@@ -0,0 +1 @@
+

sys2txt/__main__.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+"""Main entry point for sys2txt CLI."""
+
+import argparse
+import os
+import sys
+import tempfile
+from datetime import datetime
+
+from .audio import record_once, segment_and_transcribe_live
+from .constants import WHISPER_MODEL
+from .pulse import get_default_monitor_source, list_pulse_sources
+from .transcribe import transcribe_file
+
+
+def get_timestamp_filename() -> str:
+    """Generate a timestamp-based filename for output files.
+
+    Returns:
+        A filename string in the format: YYYY-MM-DD_HH-MM-SS.txt
+    """
+    return datetime.now().strftime("%Y-%m-%d_%H-%M-%S.txt")
+
+
+def ensure_output_dir() -> str:
+    """Ensure the output directory exists and return its path.
+
+    Returns:
+        Absolute path to the output directory
+    """
+    output_dir = os.path.join(os.getcwd(), "output")
+    os.makedirs(output_dir, exist_ok=True)
+    return output_dir
+
+
+def main():
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(description="Record Ubuntu system audio and transcribe with Whisper.")
+    sub = parser.add_subparsers(dest="mode", required=True)
+
+    common = argparse.ArgumentParser(add_help=False)
+    common.add_argument(
+        "--source", help="PulseAudio source name (e.g., <sink>.monitor). Defaults to auto.", default=None
+    )
+    common.add_argument(
+        "--model",
+        dest="model_size",
+        default=WHISPER_MODEL,
+        help=f"Whisper model size (default: {WHISPER_MODEL})",
+    )
+    common.add_argument(
+        "--engine", choices=["auto", "faster", "whisper"], default="auto", help="Transcription engine (default: auto)"
+    )
+    common.add_argument("--language", default=None, help="Force language code (e.g., en). Defaults to auto-detect")
+    common.add_argument("--timestamps", action="store_true", help="Print timestamps with transcript")
+    common.add_argument("--list-sources", action="store_true", help="List PulseAudio sources and exit")
+
+    once = sub.add_parser("once", parents=[common], help="Record once and transcribe after")
+    once.add_argument("--duration", type=int, default=None, help="Record for N seconds instead of Ctrl-C")
+    once.add_argument("--output", default=None, help="Write transcript to file")
+    once.add_argument("--input", default=None, help="Skip recording and transcribe this existing audio file")
+
+    live = sub.add_parser("live", parents=[common], help="Segmented live transcription")
+    live.add_argument("--segment-seconds", type=int, default=8, help="Segment length in seconds (default: 8)")
+    live.add_argument("--output", default=None, help="Append live transcript to this file as it's produced")
+
+    args = parser.parse_args()
+
+    if args.list_sources:
+        sources = list_pulse_sources()
+        if not sources:
+            print("No PulseAudio sources found. Is PulseAudio/PipeWire running?", file=sys.stderr)
+            sys.exit(1)
+        print("Available PulseAudio sources:")
+        for name, _ in sources:
+            print("  ", name)
+        return
+
+    # Determine source
+    source = args.source or get_default_monitor_source()
+
+    if args.mode == "once":
+        # Determine output file path
+        output_dir = ensure_output_dir()
+        if args.output:
+            # If user specified a path, use it as-is (could be relative or absolute)
+            output_file = args.output
+        else:
+            # Generate timestamp-based filename in output/ directory
+            output_file = os.path.join(output_dir, get_timestamp_filename())
+
+        if args.input:
+            audio_path = args.input
+        else:
+            # Make a temp WAV, record until duration/ctrl-c, then transcribe
+            with tempfile.TemporaryDirectory(prefix="sys2txt_") as tmp:
+                wav = os.path.join(tmp, "capture.wav")
+                record_once(source=source, out_wav=wav, sample_rate=16000, channels=1, duration=args.duration)
+                audio_path = wav
+                text = transcribe_file(
+                    audio_path,
+                    engine=args.engine,
+                    model_size=args.model_size,
+                    language=args.language,
+                    timestamps=args.timestamps,
+                )
+                print(text)
+                with open(output_file, "w", encoding="utf-8") as w:
+                    w.write(text + "\n")
+                print(f"Transcript saved to: {output_file}")
+                return
+        # If input provided, just transcribe it
+        text = transcribe_file(
+            audio_path,
+            engine=args.engine,
+            model_size=args.model_size,
+            language=args.language,
+            timestamps=args.timestamps,
+        )
+        print(text)
+        with open(output_file, "w", encoding="utf-8") as w:
+            w.write(text + "\n")
+        print(f"Transcript saved to: {output_file}")
+
+    elif args.mode == "live":
+        # Determine output file path
+        output_dir = ensure_output_dir()
+        if args.output:
+            # If user specified a path, use it as-is (could be relative or absolute)
+            output_file = args.output
+        else:
+            # Generate timestamp-based filename in output/ directory
+            output_file = os.path.join(output_dir, get_timestamp_filename())
+
+        print(f"Live transcript will be saved to: {output_file}")
+
+        def transcribe_segment(file_path: str, segment_index: int) -> str:
+            """Transcribe a segment and format with optional timestamp prefix."""
+            text = transcribe_file(
+                file_path,
+                engine=args.engine,
+                model_size=args.model_size,
+                language=args.language,
+                timestamps=args.timestamps,
+            )
+            if args.timestamps:
+                # Add segment time window prefix
+                start = segment_index * args.segment_seconds
+                end = start + args.segment_seconds
+                prefix = f"[{start:>5d}-{end:>5d}s] "
+                return prefix + text.strip()
+            else:
+                return text.strip()
+
+        segment_and_transcribe_live(
+            source=source,
+            sample_rate=16000,
+            channels=1,
+            segment_seconds=args.segment_seconds,
+            transcribe_callback=transcribe_segment,
+            output_path=output_file,
+        )
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except RuntimeError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+    except KeyboardInterrupt:
+        pass

sys2txt/audio.py

@@ -0,0 +1,169 @@
+"""Audio recording functionality using ffmpeg and PulseAudio/PipeWire."""
+
+import os
+import signal
+import subprocess
+import tempfile
+import time
+from typing import Optional
+
+from .utils import which
+
+
+def record_once(source: str, out_wav: str, sample_rate: int, channels: int, duration: Optional[int]) -> None:
+    """Record audio once from a PulseAudio source to a WAV file.
+
+    Args:
+        source: PulseAudio source name (e.g., "sink.monitor")
+        out_wav: Output WAV file path
+        sample_rate: Sample rate in Hz (e.g., 16000)
+        channels: Number of audio channels (1 for mono, 2 for stereo)
+        duration: Optional recording duration in seconds. If None, records until interrupted.
+    """
+    ffmpeg = which("ffmpeg")
+    args = [
+        ffmpeg,
+        "-nostdin",
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-f",
+        "pulse",
+        "-i",
+        source,
+        "-ac",
+        str(channels),
+        "-ar",
+        str(sample_rate),
+        "-f",
+        "wav",
+    ]
+    if duration is not None and duration > 0:
+        args.extend(["-t", str(duration)])
+    args.append(out_wav)
+
+    print(f"Recording system audio from source '{source}' at {sample_rate} Hz, mono -> {out_wav}")
+    print("Press Ctrl-C to stop early..." if duration is None else f"Recording for {duration} seconds...")
+
+    proc = subprocess.Popen(args)
+    try:
+        proc.wait()
+    except KeyboardInterrupt:
+        try:
+            proc.send_signal(signal.SIGINT)
+        except Exception:
+            pass
+        proc.wait()
+    print("Recording finished.")
+
+
+def segment_and_transcribe_live(
+    source: str,
+    sample_rate: int,
+    channels: int,
+    segment_seconds: int,
+    transcribe_callback,
+    output_path: Optional[str],
+) -> None:
+    """Record audio in segments and transcribe each segment as it's created.
+
+    Args:
+        source: PulseAudio source name
+        sample_rate: Sample rate in Hz
+        channels: Number of audio channels
+        segment_seconds: Length of each segment in seconds
+        transcribe_callback: Function to call for each segment. Should accept (file_path, segment_index) and return text
+        output_path: Optional file path to append transcripts to
+    """
+    ffmpeg = which("ffmpeg")
+    with tempfile.TemporaryDirectory(prefix="sys2txt_") as tmp:
+        pattern = os.path.join(tmp, "seg_%05d.wav")
+        args = [
+            ffmpeg,
+            "-hide_banner",
+            "-loglevel",
+            "error",
+            "-f",
+            "pulse",
+            "-i",
+            source,
+            "-ac",
+            str(channels),
+            "-ar",
+            str(sample_rate),
+            "-f",
+            "segment",
+            "-segment_time",
+            str(segment_seconds),
+            "-reset_timestamps",
+            "1",
+            pattern,
+        ]
+
+        print(f"Live mode: segmenting every {segment_seconds}s from '{source}'. Press Ctrl-C to stop.")
+        proc = subprocess.Popen(args, stdin=subprocess.PIPE, stderr=subprocess.PIPE)
+        processed: set[str] = set()
+        try:
+            while True:
+                # sorted ensures we process in chronological order
+                files = sorted(f for f in os.listdir(tmp) if f.startswith("seg_") and f.endswith(".wav"))
+                new_files = [f for f in files if f not in processed]
+                for f in new_files:
+                    full = os.path.join(tmp, f)
+                    # Ensure the segment has been finalized and has content
+                    if os.path.getsize(full) < 64:
+                        continue
+                    processed.add(f)
+
+                    # Extract segment index from filename
+                    try:
+                        idx = int(os.path.splitext(f)[0].split("_")[-1])
+                    except Exception:
+                        idx = 0
+
+                    text = transcribe_callback(full, idx)
+                    print(text, flush=True)
+                    if output_path:
+                        with open(output_path, "a", encoding="utf-8") as w:
+                            w.write(text + "\n")
+
+                # If ffmpeg has exited and no new files pending, break
+                ret = proc.poll()
+                if ret is not None:
+                    # flush remaining unprocessed files
+                    files = sorted(f for f in os.listdir(tmp) if f.startswith("seg_") and f.endswith(".wav"))
+                    new_files = [f for f in files if f not in processed]
+                    for f in new_files:
+                        full = os.path.join(tmp, f)
+                        if os.path.getsize(full) < 64:
+                            continue
+                        processed.add(f)
+                        try:
+                            idx = int(os.path.splitext(f)[0].split("_")[-1])
+                        except Exception:
+                            idx = 0
+                        text = transcribe_callback(full, idx)
+                        print(text, flush=True)
+                        if output_path:
+                            with open(output_path, "a", encoding="utf-8") as w:
+                                w.write(text + "\n")
+                    break
+                time.sleep(0.3)
+        except KeyboardInterrupt:
+            print("\nStopping live capture...")
+            try:
+                # Send 'q' command to ffmpeg to quit gracefully
+                if proc.stdin:
+                    proc.stdin.write(b"q")
+                    proc.stdin.flush()
+                    proc.stdin.close()
+                # Give ffmpeg time to finish the current segment
+                try:
+                    proc.wait(timeout=3.0)
+                except subprocess.TimeoutExpired:
+                    # If it doesn't finish in time, terminate it
+                    proc.terminate()
+                    proc.wait()
+            except Exception:
+                pass
+            print("Stopped live capture.")

sys2txt/constants.py

@@ -0,0 +1,4 @@
+import os
+
+WHISPER_MODEL = os.getenv("WHISPER_MODEL", "small.en")
+"Default Whisper model"

sys2txt/pulse.py

@@ -0,0 +1,48 @@
+"""PulseAudio/PipeWire integration for source enumeration and selection."""
+
+import subprocess
+from typing import List, Tuple
+
+
+def run_command(cmd: List[str]) -> Tuple[int, str, str]:
+    """Run a command and return exit code, stdout, stderr."""
+    p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+    out, err = p.communicate()
+    return p.returncode, out, err
+
+
+def list_pulse_sources() -> List[Tuple[str, str]]:
+    """Return list of (name, description) for PulseAudio sources."""
+    try:
+        code, out, _ = run_command(["pactl", "list", "short", "sources"])
+        if code != 0:
+            return []
+        items: List[Tuple[str, str]] = []
+        for line in out.splitlines():
+            # Format: index\tname\tmodule\tsampleSpec\tstate
+            parts = line.split("\t")
+            if len(parts) >= 2:
+                name = parts[1]
+                items.append((name, name))
+        return items
+    except FileNotFoundError:
+        return []
+
+
+def get_default_monitor_source() -> str:
+    """Pick the default sink's .monitor if available; otherwise the first *.monitor source; else 'default'."""
+    try:
+        code, sink_name, _ = run_command(["pactl", "get-default-sink"])
+        sink_name = sink_name.strip()
+        if code == 0 and sink_name:
+            candidate = f"{sink_name}.monitor"
+            sources = [s for s, _ in list_pulse_sources()]
+            if candidate in sources:
+                return candidate
+        # fallback: first *.monitor source
+        for s, _ in list_pulse_sources():
+            if s.endswith(".monitor"):
+                return s
+    except Exception:
+        pass
+    return "default"

sys2txt/transcribe.py

@@ -0,0 +1,82 @@
+"""Transcription functionality using Whisper models."""
+
+import os
+from typing import Optional
+
+
+def transcribe_file(path: str, engine: str, model_size: str, language: Optional[str], timestamps: bool) -> str:
+    """Transcribe an audio file using the specified Whisper engine.
+
+    Args:
+        path: Path to audio file
+        engine: Engine to use ("auto", "faster", or "whisper")
+        model_size: Whisper model size (tiny, base, small, medium, large-v2)
+        language: Optional language code (e.g., "en"). If None, auto-detect.
+        timestamps: Whether to include timestamps in output
+
+    Returns:
+        Transcribed text
+    """
+    engine = engine.lower()
+    if engine == "auto":
+        try:
+            engine = "faster"
+        except Exception:
+            engine = "whisper"
+
+    if engine == "faster":
+        return _transcribe_faster_whisper(path, model_size, language, timestamps)
+    elif engine == "whisper":
+        return _transcribe_openai_whisper(path, model_size, language, timestamps)
+    else:
+        raise ValueError(f"Unknown engine: {engine}")
+
+
+def _transcribe_faster_whisper(path: str, model_size: str, language: Optional[str], timestamps: bool) -> str:
+    """Transcribe using faster-whisper (ctranslate2 backend)."""
+    try:
+        from faster_whisper import WhisperModel  # type: ignore
+    except Exception as e:
+        raise RuntimeError("faster-whisper is not installed. pip install faster-whisper") from e
+
+    # Auto device selection
+    device = "cpu"
+    compute_type = "int8"
+    # If user has a CUDA-enabled ctranslate2 build installed, they can switch manually by editing below
+    # or by setting environment variable SYS2TXT_DEVICE=cuda
+    if os.environ.get("SYS2TXT_DEVICE") == "cuda":
+        device = "cuda"
+        compute_type = "float16"
+
+    model = WhisperModel(model_size, device=device, compute_type=compute_type)
+    segments, info = model.transcribe(path, vad_filter=True, language=language)
+    if timestamps:
+        lines = []
+        for seg in segments:
+            s = f"[{seg.start:6.2f}-{seg.end:6.2f}] {seg.text.strip()}"
+            lines.append(s)
+        return "\n".join(lines)
+    else:
+        text_parts = [seg.text for seg in segments]
+        return " ".join(t.strip() for t in text_parts).strip()
+
+
+def _transcribe_openai_whisper(path: str, model_size: str, language: Optional[str], timestamps: bool) -> str:
+    """Transcribe using openai-whisper (reference implementation)."""
+    try:
+        import whisper  # type: ignore
+    except Exception as e:
+        raise RuntimeError("openai-whisper is not installed. pip install openai-whisper") from e
+
+    model = whisper.load_model(model_size)
+    result = model.transcribe(path, language=language)
+    if timestamps and "segments" in result:
+        lines = []
+        for seg in result.get("segments", []):
+            start = seg.get("start", 0.0)
+            end = seg.get("end", 0.0)
+            text = seg.get("text", "").strip()
+            lines.append(f"[{start:6.2f}-{end:6.2f}] {text}")
+        return "\n".join(lines)
+    else:
+        return result.get("text", "").strip()

sys2txt/utils.py

@@ -0,0 +1,11 @@
+"""Utility functions."""
+
+import shutil
+
+
+def which(cmd: str) -> str:
+    """Find command in PATH or raise RuntimeError if not found."""
+    path = shutil.which(cmd)
+    if not path:
+        raise RuntimeError(f"Required command not found: {cmd}. Please install it and try again.")
+    return path

sys2txt-0.1.1.dist-info/METADATA

@@ -0,0 +1,167 @@
+Metadata-Version: 2.4
+Name: sys2txt
+Version: 0.1.1
+Summary: Record system audio and transcribe to text using AI
+Author-email: Joe Heffer <jheffer@gmail.com>
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: faster-whisper>=1.0.0
+Requires-Dist: openai-whisper>=20231117
+Provides-Extra: dev
+Requires-Dist: ruff>=0.8.0; extra == "dev"
+Dynamic: license-file
+
+[![CI](https://github.com/Joe-Heffer/sys2txt/actions/workflows/ci.yml/badge.svg)](https://github.com/Joe-Heffer/sys2txt/actions/workflows/ci.yml)
+[![PyPI version](https://badge.fury.io/py/sys2txt.svg)](https://badge.fury.io/py/sys2txt)
+[![Python versions](https://img.shields.io/pypi/pyversions/sys2txt.svg)](https://pypi.org/project/sys2txt/)
+
+# System audio to text
+
+Record system audio and automatically transcribe to text using ✨AI✨.
+
+## Overview
+
+`sys2txt` is a command-line tool that records your system audio (via PulseAudio/PipeWire monitor sources) with `ffmpeg` and transcribes it locally using [Whisper](https://github.com/openai/whisper). It supports both:
+
+- On-demand: Record until you stop, then transcribe once
+- Live-ish: Segment the recording every *N* seconds and transcribe each segment as it’s created (prints continuously)
+
+You can use either the `openai-whisper` (Python) reference implementation or the [`faster-whisper`](https://github.com/SYSTRAN/faster-whisper) engine if installed. The tool auto-selects `faster-whisper` when available for better speed on CPU and especially GPU.
+
+## Installation
+
+### Prerequisites
+
+- Ubuntu with PulseAudio or PipeWire (default on modern Ubuntu)
+- ffmpeg
+- Python 3.9+ (recommended)
+
+### Install
+
+1) System packages
+
+```bash
+sudo apt update
+sudo apt install -y ffmpeg python3-venv python3-pip
+```
+
+2) Create a virtual environment and install sys2txt
+
+```bash
+cd sys2txt
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -e .
+```
+
+This installs both faster-whisper (for speed) and openai-whisper (reference implementation). The tool auto-selects faster-whisper when available or falls back to openai-whisper.
+
+## Quick start
+
+Record and transcribe once (press Ctrl-C to stop recording):
+
+```bash
+sys2txt once --model small.en
+```
+
+Live segmented transcription (prints ongoing transcript every 8s by default; Ctrl-C to stop):
+
+```bash
+sys2txt live --model small.en --segment-seconds 8
+```
+
+### Useful flags
+
+- `--source <pulse_source_name>` - Explicit PulseAudio/PipeWire source (e.g., alsa_output.pci-0000_00_1f.3.analog-stereo.monitor)
+- `--list-sources` - List available Pulse sources and exit
+- `--model <size>` - tiny|base|small|medium|large-v2 (default: small)
+- `--engine <auto|faster|whisper>` - Force a specific engine (default: auto)
+- `--language <code>` - Force language code (e.g., en). Omit to auto-detect
+- `--output <path>` - Write final transcript to a file (in live mode, appends)
+- `--duration <seconds>` - (once mode) Record fixed duration instead of waiting for Ctrl-C
+- `--segment-seconds <n>` - (live mode) Segment length in seconds (default: 8)
+- `--timestamps` - Print timestamps alongside text
+
+## Examples
+
+Record 30s of system audio from the default monitor and transcribe:
+
+```bash
+sys2txt once --duration 30 --model small --output transcript.txt
+```
+
+Use a specific PulseAudio source:
+
+```bash
+sys2txt once --source alsa_output.usb-Focusrite_Scarlett.monitor --model base
+```
+
+Live mode with shorter latency and timestamps:
+
+```bash
+sys2txt live --segment-seconds 5 --timestamps
+```
+
+Force the reference openai-whisper engine:
+
+```bash
+sys2txt once --engine whisper --model base
+```
+
+Transcribe an existing audio file:
+
+```bash
+sys2txt once --input recording.wav --model small
+```
+
+### Just want one-liners (no sys2txt)?
+
+Find the default sink and its monitor source:
+
+```bash
+pactl get-default-sink
+pactl list short sources | grep monitor
+```
+
+Record 30s of system audio from the default monitor to a WAV at 16 kHz mono (good for Whisper):
+
+```bash
+ffmpeg -hide_banner -loglevel error -f pulse -i "$(pactl get-default-sink).monitor" -ac 1 -ar 16000 -t 30 out.wav
+```
+
+Transcribe with openai-whisper CLI:
+
+```bash
+whisper out.wav --model small --task transcribe --language en
+```
+
+## Tips and troubleshooting
+
+- If you get silence, ensure you are using the monitor source for your output device (the name ends with `.monitor`). Use `--list-sources` to view options.
+- Make sure the application you want to capture is playing through the same output sink as your default sink. You can manage routes with `pavucontrol`.
+- PipeWire systems expose PulseAudio-compatible sources, so `-f pulse` in ffmpeg still works.
+- For better performance on CPU, use faster-whisper with model `base` or `small`. For the best accuracy, use `medium` or `large-v2` (these are heavier).
+- GPU acceleration for faster-whisper requires a compatible ctranslate2 CUDA wheel. Set `SYS2TXT_DEVICE=cuda` to enable it. If not available, it will run on CPU.
+
+## Development
+
+Install with development dependencies:
+
+```bash
+pip install -e ".[dev]"
+```
+
+Run unit tests:
+
+```bash
+python -m unittest discover -s tests -p "test_*.py"
+```
+
+Format and lint code:
+
+```bash
+ruff format src/
+ruff check src/
+```

sys2txt-0.1.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+sys2txt/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+sys2txt/__main__.py,sha256=aTFF9J885f-548RmiurZCCJrm0bar09gM0XuARRxQ6E,6525
+sys2txt/audio.py,sha256=cTcYAAgiRipmLkaEsl5VIUCEliGW3fbjZ9wWm6rq2bw,5987
+sys2txt/constants.py,sha256=iqZGZIHROECa4iQTcVNQxFSmyEbZ5Eufd7O1Ikp7zjg,90
+sys2txt/pulse.py,sha256=d1vcrS-7opktxRaes8Yguo_0WVTSbfkm9mes7wyUGS8,1694
+sys2txt/transcribe.py,sha256=-6o9nSWzW2U8oIRMzA58nXxumYESv0s_9xIEYgBZSEA,3129
+sys2txt/utils.py,sha256=h94hGzrIcp9aTSZqrWCeU9oUvxxHENQ1sq2Co6i47qM,298
+sys2txt-0.1.1.dist-info/licenses/LICENSE,sha256=IuEA70YNQHOd_2f9RbqyzAvpGOz3qbA__ms65xlQn6Y,1067
+sys2txt-0.1.1.dist-info/METADATA,sha256=0iMaalfrlq_X-A9y6Gb8w8-2McMU8HqsLJF7OBDVZOo,5196
+sys2txt-0.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sys2txt-0.1.1.dist-info/entry_points.txt,sha256=-g_M1WBoKXNaKfByGAPFjz_3fLCA2SE4BwSr4PlDcgc,50
+sys2txt-0.1.1.dist-info/top_level.txt,sha256=V_PwMcyUAVJZdER8Jr616x_wWC7wJ7OdQu6nD9Hbv2E,8
+sys2txt-0.1.1.dist-info/RECORD,,

sys2txt-0.1.1.dist-info/WHEEL

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

sys2txt-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sys2txt = sys2txt.__main__:main

sys2txt-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Joe Heffer
+
+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.

sys2txt-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+sys2txt