patch-code 0.1.0__py3-none-any.whl

patch/utils.py

@@ -0,0 +1,348 @@
+import os
+import platform
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+import oslex
+
+from patch.dump import dump  # noqa: F401
+from patch.waiting import Spinner
+
+IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".gif", ".bmp", ".tiff", ".webp", ".pdf"}
+
+
+class IgnorantTemporaryDirectory:
+    def __init__(self):
+        if sys.version_info >= (3, 10):
+            self.temp_dir = tempfile.TemporaryDirectory(ignore_cleanup_errors=True)
+        else:
+            self.temp_dir = tempfile.TemporaryDirectory()
+
+    def __enter__(self):
+        return self.temp_dir.__enter__()
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.cleanup()
+
+    def cleanup(self):
+        try:
+            self.temp_dir.cleanup()
+        except (OSError, PermissionError, RecursionError):
+            pass  # Ignore errors (Windows and potential recursion)
+
+    def __getattr__(self, item):
+        return getattr(self.temp_dir, item)
+
+
+class ChdirTemporaryDirectory(IgnorantTemporaryDirectory):
+    def __init__(self):
+        try:
+            self.cwd = os.getcwd()
+        except FileNotFoundError:
+            self.cwd = None
+
+        super().__init__()
+
+    def __enter__(self):
+        res = super().__enter__()
+        os.chdir(Path(self.temp_dir.name).resolve())
+        return res
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self.cwd:
+            try:
+                os.chdir(self.cwd)
+            except FileNotFoundError:
+                pass
+        super().__exit__(exc_type, exc_val, exc_tb)
+
+
+class GitTemporaryDirectory(ChdirTemporaryDirectory):
+    def __enter__(self):
+        dname = super().__enter__()
+        self.repo = make_repo(dname)
+        return dname
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        del self.repo
+        super().__exit__(exc_type, exc_val, exc_tb)
+
+
+def make_repo(path=None):
+    import git
+
+    if not path:
+        path = "."
+    repo = git.Repo.init(path)
+    repo.config_writer().set_value("user", "name", "Test User").release()
+    repo.config_writer().set_value("user", "email", "testuser@example.com").release()
+
+    return repo
+
+
+def is_image_file(file_name):
+    """
+    Check if the given file name has an image file extension.
+
+    :param file_name: The name of the file to check.
+    :return: True if the file is an image, False otherwise.
+    """
+    file_name = str(file_name)  # Convert file_name to string
+    return any(file_name.endswith(ext) for ext in IMAGE_EXTENSIONS)
+
+
+def safe_abs_path(res):
+    "Gives an abs path, which safely returns a full (not 8.3) windows path"
+    try:
+        res = Path(res).resolve()
+    except (RuntimeError, OSError):
+        res = Path(res).absolute()
+    return str(res)
+
+
+def format_content(role, content):
+    formatted_lines = []
+    for line in content.splitlines():
+        formatted_lines.append(f"{role} {line}")
+    return "\n".join(formatted_lines)
+
+
+def format_messages(messages, title=None):
+    output = []
+    if title:
+        output.append(f"{title.upper()} {'*' * 50}")
+
+    for msg in messages:
+        output.append("-------")
+        role = msg["role"].upper()
+        content = msg.get("content")
+        if isinstance(content, list):  # Handle list content (e.g., image messages)
+            for item in content:
+                if isinstance(item, dict):
+                    for key, value in item.items():
+                        if isinstance(value, dict) and "url" in value:
+                            output.append(f"{role} {key.capitalize()} URL: {value['url']}")
+                        else:
+                            output.append(f"{role} {key}: {value}")
+                else:
+                    output.append(f"{role} {item}")
+        elif isinstance(content, str):  # Handle string content
+            output.append(format_content(role, content))
+        function_call = msg.get("function_call")
+        if function_call:
+            output.append(f"{role} Function Call: {function_call}")
+
+    return "\n".join(output)
+
+
+def show_messages(messages, title=None, functions=None):
+    formatted_output = format_messages(messages, title)
+    print(formatted_output)
+
+    if functions:
+        dump(functions)
+
+
+def split_chat_history_markdown(text, include_tool=False):
+    messages = []
+    user = []
+    assistant = []
+    tool = []
+    lines = text.splitlines(keepends=True)
+
+    def append_msg(role, lines):
+        lines = "".join(lines)
+        if lines.strip():
+            messages.append(dict(role=role, content=lines))
+
+    for line in lines:
+        if line.startswith("# "):
+            continue
+        if line.startswith("> "):
+            append_msg("assistant", assistant)
+            assistant = []
+            append_msg("user", user)
+            user = []
+            tool.append(line[2:])
+            continue
+        # if line.startswith("#### /"):
+        #    continue
+
+        if line.startswith("#### "):
+            append_msg("assistant", assistant)
+            assistant = []
+            append_msg("tool", tool)
+            tool = []
+
+            content = line[5:]
+            user.append(content)
+            continue
+
+        append_msg("user", user)
+        user = []
+        append_msg("tool", tool)
+        tool = []
+
+        assistant.append(line)
+
+    append_msg("assistant", assistant)
+    append_msg("user", user)
+
+    if not include_tool:
+        messages = [m for m in messages if m["role"] != "tool"]
+
+    return messages
+
+
+def get_pip_install(args):
+    cmd = [
+        sys.executable,
+        "-m",
+        "pip",
+        "install",
+        "--upgrade",
+        "--upgrade-strategy",
+        "only-if-needed",
+    ]
+    cmd += args
+    return cmd
+
+
+def run_install(cmd):
+    print()
+    print("Installing:", printable_shell_command(cmd))
+
+    # First ensure pip is available
+    ensurepip_cmd = [sys.executable, "-m", "ensurepip", "--upgrade"]
+    try:
+        subprocess.run(ensurepip_cmd, capture_output=True, check=False)
+    except Exception:
+        pass  # Continue even if ensurepip fails
+
+    try:
+        output = []
+        process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+            universal_newlines=True,
+            encoding=sys.stdout.encoding,
+            errors="replace",
+        )
+        spinner = Spinner("Installing...")
+
+        while True:
+            char = process.stdout.read(1)
+            if not char:
+                break
+
+            output.append(char)
+            spinner.step()
+
+        spinner.end()
+        return_code = process.wait()
+        output = "".join(output)
+
+        if return_code == 0:
+            print("Installation complete.")
+            print()
+            return True, output
+
+    except subprocess.CalledProcessError as e:
+        print(f"\nError running pip install: {e}")
+
+    print("\nInstallation failed.\n")
+
+    return False, output
+
+
+def find_common_root(abs_fnames):
+    try:
+        if len(abs_fnames) == 1:
+            return safe_abs_path(os.path.dirname(list(abs_fnames)[0]))
+        elif abs_fnames:
+            return safe_abs_path(os.path.commonpath(list(abs_fnames)))
+    except OSError:
+        pass
+
+    try:
+        return safe_abs_path(os.getcwd())
+    except FileNotFoundError:
+        # Fallback if cwd is deleted
+        return "."
+
+
+def format_tokens(count):
+    if count < 1000:
+        return f"{count}"
+    elif count < 10000:
+        return f"{count / 1000:.1f}k"
+    else:
+        return f"{round(count / 1000)}k"
+
+
+def touch_file(fname):
+    fname = Path(fname)
+    try:
+        fname.parent.mkdir(parents=True, exist_ok=True)
+        fname.touch()
+        return True
+    except OSError:
+        return False
+
+
+def check_pip_install_extra(io, module, prompt, pip_install_cmd, self_update=False):
+    if module:
+        try:
+            __import__(module)
+            return True
+        except (ImportError, ModuleNotFoundError, RuntimeError):
+            pass
+
+    cmd = get_pip_install(pip_install_cmd)
+
+    if prompt:
+        io.tool_warning(prompt)
+
+    if self_update and platform.system() == "Windows":
+        io.tool_output("Run this command to update:")
+        print()
+        print(printable_shell_command(cmd))  # plain print so it doesn't line-wrap
+        return
+
+    if not io.confirm_ask("Run pip install?", default="y", subject=printable_shell_command(cmd)):
+        return
+
+    success, output = run_install(cmd)
+    if success:
+        if not module:
+            return True
+        try:
+            __import__(module)
+            return True
+        except (ImportError, ModuleNotFoundError, RuntimeError) as err:
+            io.tool_error(str(err))
+            pass
+
+    io.tool_error(output)
+
+    print()
+    print("Install failed, try running this command manually:")
+    print(printable_shell_command(cmd))
+
+
+def printable_shell_command(cmd_list):
+    """
+    Convert a list of command arguments to a properly shell-escaped string.
+
+    Args:
+        cmd_list (list): List of command arguments.
+
+    Returns:
+        str: Shell-escaped command string.
+    """
+    return oslex.join(cmd_list)

patch/versioncheck.py

@@ -0,0 +1,130 @@
+import os
+import sys
+import time
+from importlib.metadata import PackageNotFoundError, version
+from pathlib import Path
+
+import packaging.version
+
+import patch
+from patch import utils
+from patch.dump import dump  # noqa: F401
+
+VERSION_CHECK_FNAME = Path.home() / ".patch" / "caches" / "versioncheck"
+
+
+def install_from_main_branch(io):
+    """
+    Install the latest version of patch from the main branch of the GitHub repository.
+    """
+
+    return utils.check_pip_install_extra(
+        io,
+        None,
+        "Install the development version of patch from the main branch?",
+        ["git+https://github.com/PierrunoYT/patch.git"],
+        self_update=True,
+    )
+
+
+def install_upgrade(io):
+    """
+    Install the latest version of patch from PyPI.
+    """
+
+    new_ver_text = "Install latest version of Patch?"
+
+    docker_image = os.environ.get("PATCH_DOCKER_IMAGE")
+    if docker_image:
+        text = f"""
+{new_ver_text} To upgrade, run:
+
+    docker pull {docker_image}
+"""
+        io.tool_warning(text)
+        return True
+
+    success = utils.check_pip_install_extra(
+        io,
+        None,
+        new_ver_text,
+        ["patch-code"],
+        self_update=True,
+    )
+
+    if success:
+        io.tool_output("Re-run patch to use new version.")
+        sys.exit()
+
+    return
+
+
+def check_version(io, just_check=False, verbose=False):
+    latest_version = None
+    if not just_check:
+        try:
+            since = time.time() - VERSION_CHECK_FNAME.stat().st_mtime
+            if 0 <= since < 24 * 60 * 60:
+                latest_version = str(
+                    packaging.version.Version(VERSION_CHECK_FNAME.read_text().strip())
+                )
+        except (OSError, ValueError):
+            # Also handles the empty timestamp-only cache used by older versions.
+            pass
+
+    if latest_version is None:
+        # To keep startup fast, avoid importing this unless needed.
+        import requests
+
+        try:
+            response = requests.get("https://pypi.org/pypi/patch-code/json", timeout=3)
+            response.raise_for_status()
+            latest_version = str(packaging.version.Version(response.json()["info"]["version"]))
+        except (requests.RequestException, ValueError, KeyError, TypeError) as err:
+            if just_check or verbose:
+                io.tool_error(f"Unable to check for Patch updates: {err}")
+            return False
+
+        try:
+            VERSION_CHECK_FNAME.parent.mkdir(parents=True, exist_ok=True)
+            VERSION_CHECK_FNAME.write_text(latest_version)
+        except OSError:
+            # A read-only cache must not prevent the notice or normal startup.
+            pass
+
+    # Compare the installed distribution, not the inherited upstream fallback version.
+    try:
+        current_version = version("patch-code")
+    except PackageNotFoundError:
+        current_version = patch.__version__
+
+    try:
+        is_update_available = packaging.version.parse(latest_version) > packaging.version.parse(
+            current_version
+        )
+    except ValueError as err:
+        if just_check or verbose:
+            io.tool_error(f"Unable to compare Patch versions: {err}")
+        return False
+
+    if just_check or verbose:
+        io.tool_output(f"Current version: {current_version}")
+        io.tool_output(f"Latest version: {latest_version}")
+        if is_update_available:
+            io.tool_output("Update available")
+        else:
+            io.tool_output("No update available")
+
+    if just_check:
+        return is_update_available
+
+    if not is_update_available:
+        return False
+
+    io.tool_warning(f"Patch update available: {current_version} → {latest_version}")
+    docker_image = os.environ.get("PATCH_DOCKER_IMAGE")
+    if docker_image:
+        io.tool_output(f"To update, run: docker pull {docker_image}")
+    else:
+        io.tool_output("To update, run: python -m patch --upgrade")
+    return True

patch/voice.py

@@ -0,0 +1,187 @@
+import math
+import os
+import queue
+import tempfile
+import time
+import warnings
+
+from prompt_toolkit.shortcuts import prompt
+
+from patch.llm import litellm
+
+from .dump import dump  # noqa: F401
+
+warnings.filterwarnings(
+    "ignore", message="Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work"
+)
+warnings.filterwarnings("ignore", category=SyntaxWarning)
+
+
+from pydub import AudioSegment  # noqa
+from pydub.exceptions import CouldntDecodeError, CouldntEncodeError  # noqa
+
+try:
+    import soundfile as sf
+except (OSError, ModuleNotFoundError):
+    sf = None
+
+
+class SoundDeviceError(Exception):
+    pass
+
+
+class Voice:
+    max_rms = 0
+    min_rms = 1e5
+    pct = 0
+
+    threshold = 0.15
+
+    def __init__(self, audio_format="wav", device_name=None):
+        if sf is None:
+            raise SoundDeviceError
+        try:
+            print("Initializing sound device...")
+            import sounddevice as sd
+
+            self.sd = sd
+
+            devices = sd.query_devices()
+
+            if device_name:
+                # Find the device with matching name
+                device_id = None
+                for i, device in enumerate(devices):
+                    if device_name in device["name"]:
+                        device_id = i
+                        break
+                if device_id is None:
+                    available_inputs = [d["name"] for d in devices if d["max_input_channels"] > 0]
+                    raise ValueError(
+                        f"Device '{device_name}' not found. Available input devices:"
+                        f" {available_inputs}"
+                    )
+
+                print(f"Using input device: {device_name} (ID: {device_id})")
+
+                self.device_id = device_id
+            else:
+                self.device_id = None
+
+        except (OSError, ModuleNotFoundError):
+            raise SoundDeviceError
+        if audio_format not in ["wav", "mp3", "webm"]:
+            raise ValueError(f"Unsupported audio format: {audio_format}")
+        self.audio_format = audio_format
+
+    def callback(self, indata, frames, time, status):
+        """This is called (from a separate thread) for each audio block."""
+        import numpy as np
+
+        rms = np.sqrt(np.mean(indata**2))
+        self.max_rms = max(self.max_rms, rms)
+        self.min_rms = min(self.min_rms, rms)
+
+        rng = self.max_rms - self.min_rms
+        if rng > 0.001:
+            self.pct = (rms - self.min_rms) / rng
+        else:
+            self.pct = 0.5
+
+        self.q.put(indata.copy())
+
+    def get_prompt(self):
+        num = 10
+        if math.isnan(self.pct) or self.pct < self.threshold:
+            cnt = 0
+        else:
+            cnt = int(self.pct * 10)
+
+        bar = "░" * cnt + "█" * (num - cnt)
+        bar = bar[:num]
+
+        dur = time.time() - self.start_time
+        return f"Recording, press ENTER when done... {dur:.1f}sec {bar}"
+
+    def record_and_transcribe(self, history=None, language=None):
+        try:
+            return self.raw_record_and_transcribe(history, language)
+        except KeyboardInterrupt:
+            return
+        except SoundDeviceError as e:
+            print(f"Error: {e}")
+            print("Please ensure you have a working audio input device connected and try again.")
+            return
+
+    def raw_record_and_transcribe(self, history, language):
+        self.q = queue.Queue()
+
+        temp_wav = tempfile.mktemp(suffix=".wav")
+
+        try:
+            sample_rate = int(self.sd.query_devices(self.device_id, "input")["default_samplerate"])
+        except (TypeError, ValueError):
+            sample_rate = 16000  # fallback to 16kHz if unable to query device
+        except self.sd.PortAudioError:
+            raise SoundDeviceError(
+                "No audio input device detected. Please check your audio settings and try again."
+            )
+
+        self.start_time = time.time()
+
+        try:
+            with self.sd.InputStream(
+                samplerate=sample_rate, channels=1, callback=self.callback, device=self.device_id
+            ):
+                prompt(self.get_prompt, refresh_interval=0.1)
+        except self.sd.PortAudioError as err:
+            raise SoundDeviceError(f"Error accessing audio input device: {err}")
+
+        with sf.SoundFile(temp_wav, mode="x", samplerate=sample_rate, channels=1) as file:
+            while not self.q.empty():
+                file.write(self.q.get())
+
+        use_audio_format = self.audio_format
+
+        # Check file size and offer to convert to mp3 if too large
+        file_size = os.path.getsize(temp_wav)
+        if file_size > 24.9 * 1024 * 1024 and self.audio_format == "wav":
+            print("\nWarning: {temp_wav} is too large, switching to mp3 format.")
+            use_audio_format = "mp3"
+
+        filename = temp_wav
+        if use_audio_format != "wav":
+            try:
+                new_filename = tempfile.mktemp(suffix=f".{use_audio_format}")
+                audio = AudioSegment.from_wav(temp_wav)
+                audio.export(new_filename, format=use_audio_format)
+                os.remove(temp_wav)
+                filename = new_filename
+            except (CouldntDecodeError, CouldntEncodeError) as e:
+                print(f"Error converting audio: {e}")
+            except (OSError, FileNotFoundError) as e:
+                print(f"File system error during conversion: {e}")
+            except Exception as e:
+                print(f"Unexpected error during audio conversion: {e}")
+
+        with open(filename, "rb") as fh:
+            try:
+                transcript = litellm.transcription(
+                    model="whisper-1", file=fh, prompt=history, language=language
+                )
+            except Exception as err:
+                print(f"Unable to transcribe {filename}: {err}")
+                return
+
+        if filename != temp_wav:
+            os.remove(filename)
+
+        text = transcript.text
+        return text
+
+
+if __name__ == "__main__":
+    api_key = os.getenv("OPENAI_API_KEY")
+    if not api_key:
+        raise ValueError("Please set the OPENAI_API_KEY environment variable.")
+    print(Voice().record_and_transcribe())