cli2 5.2.2__tar.gz → 5.2.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: cli2
-Version: 5.2.2
+Version: 5.2.3
 Summary: image:: https://yourlabs.io/oss/cli2/badges/master/pipeline.svg
 Home-page: https://yourlabs.io/oss/cli2
 Author: James Pic

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

@@ -29,6 +29,7 @@ from .log import configure, log, parse
 from .mask import Mask
 from .notlevenshtein import closest, closest_path
 from .proc import Proc
+from .find import Find
 from .table import Table
 
 

cli2-5.2.3/cli2/find.py

@@ -0,0 +1,189 @@
+"""
+Effecient git-aware file finder with filtering capabilities.
+
+Uses Linux commands: find, comm and git-ignore for an efficient path walker.
+
+Example usage:
+
+.. code-block:: python
+
+    # Simple usage with default root
+    finder = cli2.Find()
+    files = finder.files()
+    dirs = finder.dirs()
+
+    # Usage with filters and callback
+    def callback(filepath):
+        print(f"Found: {filepath}")
+
+    finder = cli2.Find(
+        root="/path/to/repo",
+        glob_include=['*.py'],
+        glob_exclude=['*test*'],
+        file_callback=callback
+    )
+    files = finder.files()
+    dirs = finder.dirs()
+"""
+import cli2
+from fnmatch import fnmatch
+from pathlib import Path
+import os
+
+
+class Find:
+    """
+    A class to walk through files and directories not ignored by git with
+    optional filtering.
+
+    .. py:attribute:: root
+
+        Root directory for file operations
+
+    .. py:attribute:: glob_include
+
+        Optional list of glob patterns to include
+
+    .. py:attribute:: glob_exclude
+
+        Optional list of glob patterns to exclude
+
+    .. py:attribute:: file_callback
+
+        Optional callback function called for each file or directory
+    """
+
+    def __init__(
+        self,
+        root=None,
+        glob_include=None,
+        glob_exclude=None,
+        file_callback=None,
+    ):
+        """
+        Initialize Find with optional root directory, filters, and callback.
+
+        :param root: Root directory (defaults to current working directory if
+                     not specified)
+        :type root: str or pathlib.Path or None
+        :param glob_include: List of glob patterns to include
+        :type glob_include: list or None
+        :param glob_exclude: List of glob patterns to exclude
+        :type glob_exclude: list or None
+        :param file_callback: Function to call for each file or directory
+        :type file_callback: callable or None
+        """
+        self.root = Path(root if root is not None else os.getcwd()).resolve()
+        self.glob_include = glob_include if glob_include is not None else []
+        self.glob_exclude = glob_exclude if glob_exclude is not None else []
+        self.file_callback = file_callback
+
+    def _matches_filters(self, filepath):
+        """
+        Check if a file or directory matches the include/exclude filters.
+
+        :param filepath: Path to check against filters
+        :type filepath: pathlib.Path
+        :return: True if path should be included, False otherwise
+        :rtype: bool
+        """
+        filepath_str = str(filepath.relative_to(self.root))
+
+        if self.glob_include:
+            if not any(
+                fnmatch(filepath_str, pattern) for pattern in self.glob_include
+            ):
+                return False
+
+        if self.glob_exclude:
+            if any(
+                fnmatch(filepath_str, pattern) for pattern in self.glob_exclude
+            ):
+                return False
+
+        return True
+
+    def files(self, directory=None):
+        """
+        List files not ignored by git, applying filters and callback.
+
+        :param directory: Directory to start search from (defaults to root if
+                          not specified)
+        :type directory: str or pathlib.Path or None
+        :return: List of Path objects for files not ignored by git that match
+                 filters
+        :rtype: list
+        :raises RuntimeError: If the git command fails
+        """
+        base_path = Path(directory).resolve() if directory else self.root
+
+        cmd = ' '.join([
+            f'comm -23 <(find {base_path} -type f | sort)',
+            f'<(find {base_path} -type f | git check-ignore --stdin | sort)'
+        ])
+        proc = cli2.Proc("bash", "-c", cmd).wait()
+
+        if proc.rc != 0:
+            raise RuntimeError(
+                f"Command failed with return code {proc.rc}: {proc.stderr}"
+            )
+
+        files = []
+        for line in proc.stdout.splitlines():
+            if not line.strip():
+                continue
+
+            filepath = (base_path / line.strip()).resolve()
+
+            if (
+                not self.glob_include and not self.glob_exclude
+            ) or self._matches_filters(filepath):
+                files.append(filepath)
+                if self.file_callback:
+                    self.file_callback(filepath)
+
+        return files
+
+    def dirs(self, directory=None):
+        """
+        List directories not ignored by git, applying filters and callback.
+
+        :param directory: Directory to start search from (defaults to root if
+                          not specified)
+        :type directory: str or pathlib.Path or None
+        :return: List of Path objects for directories not ignored by git that
+                 match filters
+        :rtype: list
+        :raises RuntimeError: If the git command fails
+        """
+        base_path = Path(directory).resolve() if directory else self.root
+
+        cmd = ' '.join([
+            f'comm -23 <(find {base_path} -type d | sort)',
+            f'<(find {base_path} -type d | git check-ignore --stdin | sort)'
+        ])
+        proc = cli2.Proc("bash", "-c", cmd).wait()
+
+        if proc.rc != 0:
+            raise RuntimeError(
+                f"Command failed with return code {proc.rc}: {proc.stderr}"
+            )
+
+        dirs = []
+        for line in proc.stdout.splitlines():
+            if not line.strip():
+                continue
+
+            dirpath = (base_path / line.strip()).resolve()
+
+            if dirpath == base_path:
+                continue
+
+            if (
+                not self.glob_include and not self.glob_exclude
+            ) or self._matches_filters(dirpath):
+                dirs.append(dirpath)
+                if self.file_callback:
+                    self.file_callback(dirpath)
+
+        return dirs

{cli2-5.2.2 → cli2-5.2.3}/cli2/proc.py

@@ -14,22 +14,21 @@ Example usage:
     # pass shell command in a string for convenience
     proc = cli2.Proc('foo bar')
 
-    # or as list, butter when building commands
+    # or as list, better when building commands
     proc = cli2.Proc('foo', 'bar')
 
     # run in sync mode (ie. for jinja2)
-    proc.wait_sync()
+    proc.wait()
 
     # OR run in async loop
-    await proc.wait()
+    await proc.waita()
 
     # You can chain
-    proc = cli2.Proc('hi').wait_sync()
-    proc = await cli2.Proc('hi').wait()
+    proc = cli2.Proc('hi').wait()
+    proc = await cli2.Proc('hi').waita()
 
 .. note:: There are also start functions, sync and async, in case you want to
           start the proc and wait later.
-
 """
 import asyncio
 import os
@@ -137,7 +136,7 @@ class Proc:
     def cmd(self, value):
         self.args = shlex.split(value)
 
-    async def start(self):
+    async def starta(self):
         """
         Launch the subprocess asynchronously.
 
@@ -167,7 +166,7 @@ class Proc:
         )
         return self
 
-    async def wait(self):
+    async def waita(self):
         """
         Wait for process completion with timeout handling.
 
@@ -176,7 +175,7 @@ class Proc:
         :return: Self reference for method chaining
         """
         if not self.started:
-            await self.start()
+            await self.starta()
 
         try:
             if self.timeout:
@@ -217,7 +216,7 @@ class Proc:
             if not self.quiet:
                 print(decoded_line)
 
-    def start_sync(self):
+    def start(self):
         """
         Start the subprocess synchronously without waiting for output.
         """
@@ -236,16 +235,16 @@ class Proc:
             universal_newlines=True
         )
         self.started = True
-        # Do NOT start output handling here; defer to wait_sync
+        # Do NOT start output handling here; defer to wait
         return self
 
-    def wait_sync(self):
+    def wait(self):
         """
         Wait for process completion synchronously with timeout handling.
         Collects output streams after waiting.
         """
         if not self.started:
-            self.start_sync()
+            self.start()
 
         try:
             if self.timeout:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: cli2
-Version: 5.2.2
+Version: 5.2.3
 Summary: image:: https://yourlabs.io/oss/cli2/badges/master/pipeline.svg
 Home-page: https://yourlabs.io/oss/cli2
 Author: James Pic

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

@@ -10,6 +10,7 @@ cli2/colors.py
 cli2/configuration.py
 cli2/decorators.py
 cli2/display.py
+cli2/find.py
 cli2/interactive.py
 cli2/lock.py
 cli2/log.py
@@ -46,6 +47,7 @@ tests/test_configuration.py
 tests/test_decorators.py
 tests/test_display.py
 tests/test_entry_point.py
+tests/test_find.py
 tests/test_group.py
 tests/test_inject.py
 tests/test_interactive.py

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

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

cli2-5.2.3/tests/test_find.py

@@ -0,0 +1,131 @@
+import pytest
+from pathlib import Path
+import os
+from cli2 import Find
+
+@pytest.fixture
+def temp_git_repo(tmp_path):
+    """Create a temporary git repository with test files."""
+    # Initialize git repo
+    os.system(f"git init {tmp_path}")
+
+    # Create some test files and directories
+    (tmp_path / "src").mkdir()
+    (tmp_path / "src" / "main.py").write_text("main content")
+    (tmp_path / "src" / "utils.py").write_text("utils content")
+    (tmp_path / "tests").mkdir()
+    (tmp_path / "tests" / "test_main.py").write_text("test content")
+    (tmp_path / ".gitignore").write_text("*.pyc\n__pycache__")
+
+    # Add files to git
+    os.system(f"cd {tmp_path} && git add . && git commit -m 'Initial commit'")
+
+    return tmp_path
+
+def test_basic_initialization():
+    """Test basic Find initialization."""
+    finder = Find()
+    assert isinstance(finder.root, Path)
+    assert finder.root.is_dir()
+    assert finder.glob_include == []
+    assert finder.glob_exclude == []
+    assert finder.file_callback is None
+
+def test_custom_root_initialization(temp_git_repo):
+    """Test initialization with custom root."""
+    finder = Find(root=temp_git_repo)
+    assert finder.root == temp_git_repo.resolve()
+
+def test_files_listing(temp_git_repo):
+    """Test basic file listing."""
+    finder = Find(root=temp_git_repo)
+    files = finder.files()
+
+    file_names = {f.name for f in files}
+    assert "main.py" in file_names
+    assert "utils.py" in file_names
+    assert "test_main.py" in file_names
+    assert ".gitignore" in file_names
+
+def test_dirs_listing(temp_git_repo):
+    """Test basic directory listing."""
+    finder = Find(root=temp_git_repo)
+    dirs = finder.dirs()
+
+    dir_names = {d.name for d in dirs}
+    assert "src" in dir_names
+    assert "tests" in dir_names
+
+def test_glob_include_filter(temp_git_repo):
+    """Test glob include filtering."""
+    finder = Find(root=temp_git_repo, glob_include=["*.py"])
+    files = finder.files()
+
+    file_names = {f.name for f in files}
+    assert "main.py" in file_names
+    assert "utils.py" in file_names
+    assert "test_main.py" in file_names
+    assert ".gitignore" not in file_names
+
+def test_glob_exclude_filter(temp_git_repo):
+    """Test glob exclude filtering."""
+    finder = Find(root=temp_git_repo, glob_exclude=["*test*"])
+    files = finder.files()
+
+    file_names = {f.name for f in files}
+    assert "main.py" in file_names
+    assert "utils.py" in file_names
+    assert "test_main.py" not in file_names
+
+def test_file_callback(temp_git_repo):
+    """Test file callback functionality."""
+    called_paths = []
+    def callback(filepath):
+        called_paths.append(filepath)
+
+    finder = Find(root=temp_git_repo, file_callback=callback)
+    files = finder.files()
+
+    assert len(called_paths) == len(files)
+    assert set(called_paths) == set(files)
+
+def test_custom_directory_search(temp_git_repo):
+    """Test searching from a specific directory."""
+    finder = Find(root=temp_git_repo)
+    files = finder.files(directory=temp_git_repo / "src")
+
+    file_names = {f.name for f in files}
+    assert "main.py" in file_names
+    assert "utils.py" in file_names
+    assert "test_main.py" not in file_names
+
+def test_error_handling(temp_git_repo, monkeypatch):
+    """Test error handling when git command fails."""
+    # Mock cli2.Proc to simulate git command failure
+    class MockProc:
+        def __init__(self, *args, **kwargs):
+            pass
+        def wait(self):
+            return self
+        rc = 1
+        stderr = "Git error"
+        stdout = ""
+
+    monkeypatch.setattr("cli2.Proc", MockProc)
+
+    finder = Find(root=temp_git_repo)
+    with pytest.raises(RuntimeError, match="Command failed with return code 1: Git error"):
+        finder.files()
+
+def test_matches_filters(temp_git_repo):
+    """Test the _matches_filters method."""
+    finder = Find(
+        root=temp_git_repo,
+        glob_include=["*.py"],
+        glob_exclude=["*test*"]
+    )
+
+    assert finder._matches_filters(temp_git_repo / "src" / "main.py")
+    assert finder._matches_filters(temp_git_repo / "src" / "utils.py")
+    assert not finder._matches_filters(temp_git_repo / "tests" / "test_main.py")
+    assert not finder._matches_filters(temp_git_repo / ".gitignore")

{cli2-5.2.2 → cli2-5.2.3}/tests/test_proc.py

@@ -55,10 +55,10 @@ async def test_proc_cmd_property():
 
 
 @pytest.mark.asyncio
-async def test_proc_start_and_wait():
+async def test_proc_start_and_waita():
     proc = cli2.Proc("echo hello")
-    await proc.start()
-    await proc.wait()
+    await proc.starta()
+    await proc.waita()
     assert proc.started is True
     assert proc.waited is True
     assert proc.rc == 0
@@ -68,16 +68,16 @@ async def test_proc_start_and_wait():
 @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()
+    await proc.starta()
+    await proc.waita()
     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()
+    await proc.starta()
+    await proc.waita()
     assert proc.stdout == "hello"
     assert proc.stderr == ""
     assert proc.out == "hello"
@@ -89,8 +89,8 @@ async def test_proc_output_properties():
 @pytest.mark.asyncio
 async def test_proc_with_stderr():
     proc = cli2.Proc("bash", "-c", "echo error >&2 ")
-    await proc.start()
-    await proc.wait()
+    await proc.starta()
+    await proc.waita()
     assert proc.stdout == ""
     assert proc.stderr == "error"
     assert proc.out == "error"
@@ -102,8 +102,8 @@ async def test_proc_with_stderr():
 @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()
+    await proc.starta()
+    await proc.waita()
     assert proc.stdout == "red"
     assert proc.stdout_ansi == "\x1b[31mred\x1b[0m"
 
@@ -111,26 +111,26 @@ async def test_proc_with_ansi_codes():
 @pytest.mark.asyncio
 async def test_proc_quiet_mode():
     proc = cli2.Proc("echo hello", quiet=True)
-    await proc.start()
-    await proc.wait()
+    await proc.starta()
+    await proc.waita()
     assert proc.out == "hello"
 
 
-def test_proc_start_sync_and_wait_sync():
-    proc = cli2.Proc("echo hello").wait_sync()
+def test_proc_start_and_wait():
+    proc = cli2.Proc("echo hello").wait()
     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()
+def test_proc_start_and_wait_with_timeout():
+    proc = cli2.Proc("sleep 2", timeout=1).wait()
     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()
+def test_proc_start_and_wait_with_stderr():
+    proc = cli2.Proc("bash", "-c", "echo error >&2").wait()
     assert proc.stdout == ""
     assert proc.stderr == "error"
     assert proc.out == "error"
@@ -139,12 +139,12 @@ def test_proc_start_sync_and_wait_sync_with_stderr():
     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()
+def test_proc_start_and_wait_with_ansi_codes():
+    proc = cli2.Proc("echo -e '\033[31mred\033[0m'").wait()
     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()
+def test_proc_start_and_wait_quiet_mode():
+    proc = cli2.Proc("echo hello", quiet=True).wait()
     assert proc.out == "hello"