cli2 5.2.1__tar.gz → 5.2.2__tar.gz

{cli2-5.2.1/cli2.egg-info → cli2-5.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: cli2
-Version: 5.2.1
+Version: 5.2.2
 Summary: image:: https://yourlabs.io/oss/cli2/badges/master/pipeline.svg
 Home-page: https://yourlabs.io/oss/cli2
 Author: James Pic
@@ -63,6 +63,7 @@ Batteries included, all of which are useful on their own:
   testing library so that you can go straight to the point in pytest
 - a good old fcntl based locking
 - a command line to run any python function over a beautiful CLI
-- **AI assisted programing CLI & framework with code2**
+- **AI CLI with prompt2**
+- **AI coding with code2** (TBA)
 
 `Documentation available on RTFD <https://cli2.rtfd.io>`_.

{cli2-5.2.1 → cli2-5.2.2}/README.rst

@@ -25,6 +25,7 @@ Batteries included, all of which are useful on their own:
   testing library so that you can go straight to the point in pytest
 - a good old fcntl based locking
 - a command line to run any python function over a beautiful CLI
-- **AI assisted programing CLI & framework with code2**
+- **AI CLI with prompt2**
+- **AI coding with code2** (TBA)
 
 `Documentation available on RTFD <https://cli2.rtfd.io>`_.

{cli2-5.2.1 → cli2-5.2.2}/cli2/__init__.py

@@ -11,7 +11,7 @@ from .cli import (
     Cli2Error,
     Cli2ValueError,
 )
-from .asyncio import async_resolve, async_run, Queue
+from .asyncio import async_resolve, Queue
 from .colors import colors as c
 from .theme import theme, t
 
@@ -28,6 +28,7 @@ else:
 from .log import configure, log, parse
 from .mask import Mask
 from .notlevenshtein import closest, closest_path
+from .proc import Proc
 from .table import Table
 
 

{cli2-5.2.1 → cli2-5.2.2}/cli2/asyncio.py

@@ -39,23 +39,6 @@ async def async_resolve(result, output=False):
     return result
 
 
-def async_run(coroutine):
-    """Run an async coroutine in the current event loop or create a new one.
-
-    If an event loop is already running, creates a task in that loop.
-    If no event loop is running, creates a new one and runs the coroutine.
-
-    :param coroutine: The coroutine to run (return value of an async function)
-    :return: The result of the coroutine execution
-    """
-    try:
-        loop = asyncio.get_running_loop()
-    except RuntimeError:
-        return asyncio.run(coroutine)
-    else:
-        return loop.create_task(coroutine)
-
-
 class Queue(asyncio.Queue):
     """
     An async queue with worker pool for concurrent task processing.

{cli2-5.2.1 → cli2-5.2.2}/cli2/interactive.py

@@ -3,6 +3,7 @@ import os
 import shlex
 import subprocess
 import tempfile
+from pathlib import Path
 
 from .log import log
 
@@ -49,32 +50,47 @@ def editor(content=None):
 
     Like git rebase -i does!
 
-    :param content: Initial content if any
+    - If a file path is given, edit in place.
+    - Otherwise, write to a temporary file.
+    - Anyway: return the written contents.
+
+    :param content: Initial content if any, or a file path
     :return: The edited content after $EDITOR exit
     """
-    tmp = tempfile.NamedTemporaryFile(mode='w+', delete=False, suffix=".txt")
-    with tmp as f:
-        f.write(content)
-        f.flush()
-        filepath = f.name
-
     editor = os.getenv('EDITOR', 'vim')
 
+    if Path(content).exists():
+        # open directly on target path
+        filepath = content
+        tmp = None
+    else:
+        tmp = tempfile.NamedTemporaryFile(
+            mode='w+',
+            delete=False,
+            suffix=".txt",
+        )
+        with tmp as f:
+            f.write(content)
+            f.flush()
+            filepath = f.name
+
+    command = f"{editor} {shlex.quote(str(filepath))}"
+
     try:
-        command = f"{editor} {shlex.quote(filepath)}"
         subprocess.run(shlex.split(command), check=True)
-
-        with open(filepath, 'r') as f:
-            content = f.read()
-        return content
     except subprocess.CalledProcessError as e:
         log.error(f"Error running Vim: {e}")
         return None
     except FileNotFoundError:
         log.warn(f"Temporary file gone?? {filepath}")
         return None
+    else:
+        with open(filepath, 'r') as f:
+            content = f.read()
+        return content
     finally:
-        try:
-            os.remove(filepath)
-        except OSError as e:
-            log.warn(f"Error deleting temporary file {filepath}: {e}")
+        if tmp:
+            try:
+                os.remove(filepath)
+            except OSError as e:
+                log.warn(f"Error deleting temporary file {filepath}: {e}")

cli2-5.2.2/cli2/proc.py

@@ -0,0 +1,303 @@
+"""
+Asyncio subprocess wrapper featuring:
+
+- Capture + live logging of stdout/stderr
+- ANSI escape code cleaning for captured output: print colored output for
+  humans, have clean output in a variable for processing, log, cache... and
+  sending to LLMs!
+- Separate start/wait methods for process control
+
+Example usage:
+
+.. code-block:: python
+
+    # pass shell command in a string for convenience
+    proc = cli2.Proc('foo bar')
+
+    # or as list, butter when building commands
+    proc = cli2.Proc('foo', 'bar')
+
+    # run in sync mode (ie. for jinja2)
+    proc.wait_sync()
+
+    # OR run in async loop
+    await proc.wait()
+
+    # You can chain
+    proc = cli2.Proc('hi').wait_sync()
+    proc = await cli2.Proc('hi').wait()
+
+.. note:: There are also start functions, sync and async, in case you want to
+          start the proc and wait later.
+
+"""
+import asyncio
+import os
+import shlex
+import re
+import subprocess
+
+from .log import log
+
+ansi_escape = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
+
+
+class Proc:
+    """
+    Asynchronous subprocess manager with advanced IO handling.
+
+    .. py:attribute:: args
+
+        Full command arguments list used to launch the process
+
+    .. py:attribute:: rc
+
+        Return Code: process exit code (available after process completes)
+
+    .. py:attribute:: out
+
+        Combined cleaned output with ANSI escape codes removed.
+
+    .. py:attribute:: out_ansi
+
+        Combined stdout/stderr output with ANSI codes preserved.
+
+    .. py:attribute:: stdout
+
+        Cleaned stdout output with ANSI escape codes removed.
+
+    .. py:attribute:: stderr
+
+        Cleaned stdout output with ANSI escape codes removed.
+
+    .. py:attribute:: stdout_ansi
+
+        Stdout output with ANSI escape codes preserved.
+
+    .. py:attribute:: stderr_ansi
+
+        Stderr output with ANSI escape codes preserved.
+    """
+    def __init__(self, cmd, *args, quiet=False, inherit=True, timeout=None,
+                 **env):
+        """
+        :param cmd: Command string (will shlex split) or initial argument
+        :param args: Additional command arguments
+        :param quiet: Suppress live output printing (default: False)
+        :param inherit: Inherit parent environment variables (default: True)
+        :param timeout: Maximum execution time in seconds (default: None)
+        :param env: Additional environment variables to set
+        :type env: Environment variables.
+        """
+        if args:
+            self.args = [cmd] + list(args)
+        else:
+            self.args = shlex.split(cmd)
+
+        self.quiet = quiet
+
+        self.env = dict()
+        if inherit:
+            self.env = os.environ.copy()
+        self.env.update(env)
+
+        self.out_raw = bytearray()
+        self.err_raw = bytearray()
+        self.raw = bytearray()
+
+        self.started = False
+        self.waited = False
+        self.timeout = timeout
+        self.rc = None
+        self.proc = None
+
+    def clone(self):
+        """
+        Create a new unstarted Proc instance with identical configuration.
+
+        :return: New Proc instance ready for execution
+        """
+        return type(self)(
+            *self.args, quiet=self.quiet, inherit=True, timeout=self.timeout,
+            **self.env
+        )
+
+    @property
+    def cmd(self):
+        """
+        Get/set the command as a shell-joinable string.
+
+        :getter: Returns shell-escaped command string
+        :setter: Parses and updates internal args list
+        :type: str
+        """
+        return shlex.join(self.args)
+
+    @cmd.setter
+    def cmd(self, value):
+        self.args = shlex.split(value)
+
+    async def start(self):
+        """
+        Launch the subprocess asynchronously.
+
+        :return: Self reference for method chaining
+        :raises RuntimeError: If process is already started
+        """
+        if self.started:
+            raise RuntimeError("Process already started")
+
+        if not self.quiet:
+            log.debug('cmd', cmd=self.cmd)
+
+        self.proc = await asyncio.create_subprocess_exec(
+            *[str(arg) for arg in self.args],
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            env={str(k): str(v) for k, v in self.env.items()},
+        )
+        self.started = True
+
+        self.stdout_task = asyncio.create_task(
+            self._handle_output(self.proc.stdout, 1)
+        )
+        self.stderr_task = asyncio.create_task(
+            self._handle_output(self.proc.stderr, 2)
+        )
+        return self
+
+    async def wait(self):
+        """
+        Wait for process completion with timeout handling.
+
+        Terminates process if timeout occurs. Gathers all output streams.
+
+        :return: Self reference for method chaining
+        """
+        if not self.started:
+            await self.start()
+
+        try:
+            if self.timeout:
+                await asyncio.wait_for(self.proc.wait(), timeout=self.timeout)
+            else:
+                await self.proc.wait()
+        except asyncio.TimeoutError:
+            print(f"Process timed out after {self.timeout}s")
+            self.proc.terminate()
+            await self.proc.wait()
+
+        await asyncio.gather(self.stdout_task, self.stderr_task)
+        self.rc = self.proc.returncode
+        self.waited = True
+        return self
+
+    async def _handle_output(self, stream, fd):
+        """
+        Internal method for stream handling.
+
+        :param stream: Output stream to monitor
+        :type stream: asyncio.StreamReader
+        :param fd: Stream identifier (1=stdout, 2=stderr)
+        :type fd: int
+        """
+        while True:
+            line = await stream.readline()
+            if not line:  # EOF
+                break
+
+            decoded_line = line.decode().rstrip()
+            if fd == 1:  # stdout
+                self.out_raw.extend(line)
+            elif fd == 2:  # stderr
+                self.err_raw.extend(line)
+            self.raw.extend(line)
+
+            if not self.quiet:
+                print(decoded_line)
+
+    def start_sync(self):
+        """
+        Start the subprocess synchronously without waiting for output.
+        """
+        if self.started:
+            raise RuntimeError("Process already started")
+
+        if not self.quiet:
+            log.debug('cmd', cmd=self.cmd)
+
+        self.proc = subprocess.Popen(
+            self.args,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            env=self.env,
+            universal_newlines=True
+        )
+        self.started = True
+        # Do NOT start output handling here; defer to wait_sync
+        return self
+
+    def wait_sync(self):
+        """
+        Wait for process completion synchronously with timeout handling.
+        Collects output streams after waiting.
+        """
+        if not self.started:
+            self.start_sync()
+
+        try:
+            if self.timeout:
+                self.rc = self.proc.wait(timeout=self.timeout)
+            else:
+                self.rc = self.proc.wait()
+        except subprocess.TimeoutExpired:
+            print(f"Process timed out after {self.timeout}s")
+            self.proc.terminate()
+            try:
+                # Grace period for termination
+                self.rc = self.proc.wait(timeout=1)
+            except subprocess.TimeoutExpired:
+                self.proc.kill()
+                self.rc = self.proc.wait()  # Final wait after kill
+
+        # Collect output after process has finished or been terminated
+        stdout, stderr = self.proc.communicate()
+        if stdout:
+            self.out_raw.extend(stdout.encode())
+            self.raw.extend(stdout.encode())
+            if not self.quiet:
+                print(stdout.rstrip())
+        if stderr:
+            self.err_raw.extend(stderr.encode())
+            self.raw.extend(stderr.encode())
+            if not self.quiet:
+                print(stderr.rstrip())
+
+        self.waited = True
+        return self
+
+    @property
+    def stdout_ansi(self):
+        return self.out_raw.decode().rstrip()
+
+    @property
+    def stderr_ansi(self):
+        return self.err_raw.decode().rstrip()
+
+    @property
+    def out_ansi(self):
+        return self.raw.decode().rstrip()
+
+    @property
+    def stdout(self):
+        return ansi_escape.sub('', self.stdout_ansi)
+
+    @property
+    def stderr(self):
+        return ansi_escape.sub('', self.stderr_ansi)
+
+    @property
+    def out(self):
+        return ansi_escape.sub('', self.out_ansi)

{cli2-5.2.1 → cli2-5.2.2/cli2.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: cli2
-Version: 5.2.1
+Version: 5.2.2
 Summary: image:: https://yourlabs.io/oss/cli2/badges/master/pipeline.svg
 Home-page: https://yourlabs.io/oss/cli2
 Author: James Pic
@@ -63,6 +63,7 @@ Batteries included, all of which are useful on their own:
   testing library so that you can go straight to the point in pytest
 - a good old fcntl based locking
 - a command line to run any python function over a beautiful CLI
-- **AI assisted programing CLI & framework with code2**
+- **AI CLI with prompt2**
+- **AI coding with code2** (TBA)
 
 `Documentation available on RTFD <https://cli2.rtfd.io>`_.

{cli2-5.2.1 → cli2-5.2.2}/cli2.egg-info/SOURCES.txt

@@ -16,6 +16,7 @@ cli2/log.py
 cli2/mask.py
 cli2/node.py
 cli2/notlevenshtein.py
+cli2/proc.py
 cli2/sphinx.py
 cli2/table.py
 cli2/test.py
@@ -53,6 +54,7 @@ tests/test_log.py
 tests/test_mask.py
 tests/test_node.py
 tests/test_notlevenshtein.py
+tests/test_proc.py
 tests/test_prompt2.py
 tests/test_restful.py
 tests/test_table.py

{cli2-5.2.1 → cli2-5.2.2}/setup.py

@@ -44,7 +44,7 @@ from setuptools import setup
 
 setup(
     name='cli2',
-    version='5.2.1',
+    version='5.2.2',
     setup_requires='setupmeta',
     packages=['cli2'],
     install_requires=[

{cli2-5.2.1 → cli2-5.2.2}/tests/test_asyncio.py

@@ -4,21 +4,6 @@ import pytest
 from unittest import mock
 
 
-def test_async_run_noloop():
-    async def task():
-        await asyncio.sleep(.01)
-
-    cli2.async_run(task())
-
-
-@pytest.mark.asyncio
-async def test_async_run_loop():
-    async def task():
-        await asyncio.sleep(.01)
-
-    cli2.async_run(task())
-
-
 @pytest.mark.asyncio
 async def test_queue_basic():
     async def task(i):

cli2-5.2.2/tests/test_proc.py

@@ -0,0 +1,150 @@
+import cli2
+import os
+import pytest
+
+
+@pytest.mark.asyncio
+async def test_proc_init_with_command_string():
+    proc = cli2.Proc("echo hello")
+    assert proc.args == ["echo", "hello"]
+    assert proc.quiet is False
+    assert proc.timeout is None
+    assert proc.env == os.environ
+
+
+@pytest.mark.asyncio
+async def test_proc_init_with_command_and_args():
+    proc = cli2.Proc("echo", "hello", "world")
+    assert proc.args == ["echo", "hello", "world"]
+
+
+@pytest.mark.asyncio
+async def test_proc_init_with_quiet():
+    proc = cli2.Proc("echo hello", quiet=True)
+    assert proc.quiet is True
+
+
+@pytest.mark.asyncio
+async def test_proc_init_with_timeout():
+    proc = cli2.Proc("echo hello", timeout=10)
+    assert proc.timeout == 10
+
+
+@pytest.mark.asyncio
+async def test_proc_init_with_env():
+    proc = cli2.Proc("echo hello", MY_VAR="test")
+    assert proc.env["MY_VAR"] == "test"
+
+
+@pytest.mark.asyncio
+async def test_proc_clone():
+    proc = cli2.Proc("echo hello", quiet=True, timeout=10, MY_VAR="test")
+    cloned_proc = proc.clone()
+    assert cloned_proc.args == proc.args
+    assert cloned_proc.quiet == proc.quiet
+    assert cloned_proc.timeout == proc.timeout
+    assert cloned_proc.env == proc.env
+
+
+@pytest.mark.asyncio
+async def test_proc_cmd_property():
+    proc = cli2.Proc("echo hello")
+    assert proc.cmd == "echo hello"
+    proc.cmd = "echo world"
+    assert proc.args == ["echo", "world"]
+
+
+@pytest.mark.asyncio
+async def test_proc_start_and_wait():
+    proc = cli2.Proc("echo hello")
+    await proc.start()
+    await proc.wait()
+    assert proc.started is True
+    assert proc.waited is True
+    assert proc.rc == 0
+    assert proc.out == "hello"
+
+
+@pytest.mark.asyncio
+async def test_proc_start_and_wait_with_timeout():
+    proc = cli2.Proc("sleep 2", timeout=1)
+    await proc.start()
+    await proc.wait()
+    assert proc.rc != 0  # Should be terminated due to timeout
+
+
+@pytest.mark.asyncio
+async def test_proc_output_properties():
+    proc = cli2.Proc("echo hello")
+    await proc.start()
+    await proc.wait()
+    assert proc.stdout == "hello"
+    assert proc.stderr == ""
+    assert proc.out == "hello"
+    assert proc.stdout_ansi == "hello"
+    assert proc.stderr_ansi == ""
+    assert proc.out_ansi == "hello"
+
+
+@pytest.mark.asyncio
+async def test_proc_with_stderr():
+    proc = cli2.Proc("bash", "-c", "echo error >&2 ")
+    await proc.start()
+    await proc.wait()
+    assert proc.stdout == ""
+    assert proc.stderr == "error"
+    assert proc.out == "error"
+    assert proc.stdout_ansi == ""
+    assert proc.stderr_ansi == "error"
+    assert proc.out_ansi == "error"
+
+
+@pytest.mark.asyncio
+async def test_proc_with_ansi_codes():
+    proc = cli2.Proc("echo -e '\033[31mred\033[0m'")
+    await proc.start()
+    await proc.wait()
+    assert proc.stdout == "red"
+    assert proc.stdout_ansi == "\x1b[31mred\x1b[0m"
+
+
+@pytest.mark.asyncio
+async def test_proc_quiet_mode():
+    proc = cli2.Proc("echo hello", quiet=True)
+    await proc.start()
+    await proc.wait()
+    assert proc.out == "hello"
+
+
+def test_proc_start_sync_and_wait_sync():
+    proc = cli2.Proc("echo hello").wait_sync()
+    assert proc.started is True
+    assert proc.waited is True
+    assert proc.rc == 0
+    assert proc.out == "hello"
+
+
+def test_proc_start_sync_and_wait_sync_with_timeout():
+    proc = cli2.Proc("sleep 2", timeout=1).wait_sync()
+    assert proc.rc != 0  # Should be terminated due to timeout
+
+
+def test_proc_start_sync_and_wait_sync_with_stderr():
+    proc = cli2.Proc("bash", "-c", "echo error >&2").wait_sync()
+    assert proc.stdout == ""
+    assert proc.stderr == "error"
+    assert proc.out == "error"
+    assert proc.stdout_ansi == ""
+    assert proc.stderr_ansi == "error"
+    assert proc.out_ansi == "error"
+
+
+def test_proc_start_sync_and_wait_sync_with_ansi_codes():
+    proc = cli2.Proc("echo -e '\033[31mred\033[0m'").wait_sync()
+    assert proc.stdout == "red"
+    assert proc.stdout_ansi == "\x1b[31mred\x1b[0m"
+
+
+def test_proc_start_sync_and_wait_sync_quiet_mode():
+    proc = cli2.Proc("echo hello", quiet=True).wait_sync()
+    assert proc.out == "hello"

{cli2-5.2.1 → cli2-5.2.2}/tests/test_prompt2.py

@@ -7,21 +7,52 @@ from unittest import mock
 from prompt2 import cli, Model, Prompt
 
 
+def test_model():
+    os.environ['MODEL'] = 'litellm foo bar=1 foo=.2'
+    model = Model()
+    assert type(model.backend).__name__ == 'LiteLLMBackend'
+    assert model.backend.model_name == 'foo'
+    assert model.backend.model_kwargs['bar'] == 1
+    assert model.backend.model_kwargs['foo'] == .2
+    del os.environ['MODEL']
+
+    os.environ['MODEL_FOO'] = 'test a=b'
+    model = Model('foo')
+    assert type(model.backend).__name__ == 'LiteLLMBackend'
+    assert model.backend.model_name == 'test'
+    assert model.backend.model_kwargs['a'] == 'b'
+
+
+def test_prompt(user, local):
+    with user.open('w') as f:
+        f.write('hello')
+
+    args = ['user', str(user), user]
+    for arg in args:
+        prompt = Prompt(arg)
+        assert prompt.path == user, arg
+        assert prompt.content == 'hello', arg
+        assert prompt.name == 'user'
+
+
 def test_paths():
-    assert cli.cli('paths') == [
-        str(Prompt.LOCAL_PATH),
-        str(Prompt.USER_PATH),
-    ]
+    paths = cli.cli('paths')
+    assert paths[0] == str(Prompt.local_path)
+    assert paths[1] == str(Prompt.user_path)
 
 
 @pytest.fixture
-def user():
-    return Path(os.getenv('PROMPT2_USER_PATH')) / 'user.txt'
+def user(prompt2_env):
+    path = Path(prompt2_env.get('PROMPT2_USER_PATH'))
+    path.mkdir(parents=True, exist_ok=True)
+    return path / 'user.txt'
 
 
 @pytest.fixture
-def local():
-    return Path(os.getenv('PROMPT2_LOCAL_PATH')) / 'local.txt'
+def local(prompt2_env):
+    path = Path(prompt2_env.get('PROMPT2_LOCAL_PATH'))
+    path.mkdir(parents=True, exist_ok=True)
+    return path / 'local.txt'
 
 
 @pytest.fixture
@@ -39,10 +70,8 @@ def kwargs(prompt2_env, user, local):
 
 @pytest.mark.asyncio
 async def test_python(prompt2_env):
-    model = Model.get()
-
-    prompt = Prompt()
-    prompt.parts.append('make a hello world in python')
+    model = Model()
+    prompt = Prompt(content='make a hello world in python')
     result = await model(prompt)
     assert 'To run this:' in result
     result = await model(prompt, 'wholefile')
@@ -67,6 +96,32 @@ def test_parsers(kwargs):
     )
 
 
+def test_ask(kwargs):
+    autotest(
+        'tests/prompt2/test_ask.txt',
+        'prompt2 ask Write hello world in python',
+        **kwargs,
+    )
+
+
+def test_command():
+    from prompt2.cli import PromptCommand
+    def test(model=None, parser=None):
+        return model, parser
+    model, parser = PromptCommand(test)()
+    assert type(model.backend).__name__ == 'LiteLLMBackend'
+    assert model.backend.model_name == Model.default
+    assert not parser
+
+    os.environ['MODEL_LOL'] = 'foo temperature=test'
+    model, parser = PromptCommand(test)('lol')
+    assert model.backend.model_name == 'foo'
+    assert model.backend.model_kwargs == dict(temperature='test')
+
+    model, parser = PromptCommand(test)('parser=wholefile')
+    assert type(parser).__name__.lower() == 'wholefile'
+
+
 def test_crud(user, kwargs):
     autotest(
         'tests/prompt2/test_edit_user.txt',
@@ -142,3 +197,14 @@ def test_crud(user, kwargs):
         'prompt2 send user wholefile',
         **kwargs,
     )
+    autotest(
+        'tests/prompt2/test_send_code_failparser.txt',
+        'prompt2 send user foeuau',
+        **kwargs,
+    )
+    os.environ['MODEL_FOO'] = 'test a=b'
+    autotest(
+        'tests/prompt2/test_send_code_failmodel.txt',
+        'prompt2 send user model=oaeoeau',
+        **kwargs,
+    )