@scemoon/cdh 1.0.5 → 1.0.7

package/tui/directory.py

@@ -1,234 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-from itertools import filterfalse
-from typing import Callable
-from time import time
-from os import PathLike
-from pathlib import Path
-
-from textual._partition import partition
-
-from tui.path_filter import PathFilter
-
-
-class ScanJob:
-    """A single directory scanning job."""
-
-    def __init__(
-        self,
-        name: str,
-        queue: asyncio.Queue[Path],
-        results: list[Path],
-        path_filter: PathFilter | None = None,
-        add_directories=False,
-    ) -> None:
-        self.queue = queue
-        self.results = results
-        self.name = name
-        self.path_filter = path_filter
-        self.add_directories = add_directories
-
-    def start(self) -> None:
-        self._task = asyncio.create_task(self.run())
-
-    async def run(self) -> None:
-        queue = self.queue
-        results = self.results
-        add_directories = self.add_directories
-        while True:
-            try:
-                scan_path = await queue.get()
-            except asyncio.QueueShutDown:
-                break
-            paths, dir_paths = await asyncio.to_thread(
-                self._scan_directory, scan_path, self.path_filter
-            )
-            if add_directories:
-                results.extend(dir_paths)
-            results.extend(paths)
-            try:
-                for path in dir_paths:
-                    await queue.put(path)
-            except asyncio.QueueShutDown:
-                break
-            queue.task_done()
-
-    def _scan_directory(
-        self, root: Path, path_filter: PathFilter | None = None
-    ) -> tuple[list[Path], list[Path]]:
-        """Perform a directory scan (done in a thread).
-
-        Args:
-            root: Path to scan.
-            path_filter: PathFilter object.
-
-        Returns:
-            A tuple of lists of paths (FILES, DIRECTORIES)
-        """
-        try:
-            paths = list(root.iterdir())
-        except IOError:
-            paths = []
-        if path_filter is not None:
-            paths = list(filterfalse(path_filter.match, paths))
-
-        try:
-            paths, dir_paths = partition(Path.is_dir, paths)
-        except IOError:
-            paths = []
-            dir_paths = []
-        return paths, dir_paths
-
-
-async def scan(
-    root: Path,
-    *,
-    max_simultaneous: int = 5,
-    path_filter: PathFilter | None = None,
-    add_directories: bool = False,
-    max_duration: float | None = 5.0,
-) -> list[Path]:
-    """Scan a directory for paths.
-
-    Args:
-        root: Root directory to scan.
-        max_simultaneous: Maximum number of scan jobs.
-        path_filter: Path filter object.
-        add_directories: Also collect directories?
-        max_duration: Maximum time in seconds to scan for, or `None` for no maximum.
-
-    Returns:
-        A list of Paths.
-    """
-    queue: asyncio.Queue[Path] = asyncio.Queue()
-    results: list[Path] = []
-    jobs = [
-        ScanJob(
-            f"scan-job #{index}",
-            queue,
-            results,
-            path_filter=path_filter,
-            add_directories=add_directories,
-        )
-        for index in range(max_simultaneous)
-    ]
-    try:
-        await queue.put(root)
-        for job in jobs:
-            job.start()
-        if max_duration is not None:
-            try:
-                async with asyncio.timeout(max_duration):
-                    await queue.join()
-            except asyncio.TimeoutError:
-                pass
-        else:
-            await queue.join()
-    except asyncio.CancelledError:
-        await queue.join()
-    queue.shutdown(immediate=True)
-    return results
-
-
-class Scan:
-    """A scan of a single directory."""
-
-    def __init__(self, root: Path, on_complete: Callable[[Scan]]) -> None:
-        self.root = root
-        self._on_complete = on_complete
-        self._complete_event = asyncio.Event()
-        self._scan_result: list[Path] = []
-        self._scan_task: asyncio.Task | None = None
-        self._scan_time = time()
-
-    @property
-    def is_complete(self) -> bool:
-        """Has the scan finished?"""
-        return self._complete_event.is_set()
-
-    def start(self) -> None:
-        self._scan_time = time()
-        self._scan_task = asyncio.create_task(self._run(), name=f"scan {self.root!s}")
-
-    async def _run(self) -> None:
-        await asyncio.to_thread(self._scan)
-        self._complete_event.set()
-        self._on_complete(self)
-
-    def _scan(self) -> None:
-        self._scan_result = list(self.root.iterdir())
-
-    async def wait(self) -> list[Path]:
-        """Get the result of the scan, potentially waiting for it to finish first.
-
-        Returns:
-            A list of paths in the root.
-        """
-        await self._complete_event.wait()
-        assert self._scan_result is not None
-        self._scan_task = None
-        return self._scan_result
-
-
-class DirectoryScanner:
-    """Object to recursively scan a directory."""
-
-    def __init__(self, root: PathLike) -> None:
-        self.root = Path(root)
-        self.directories: dict[Path, Scan] = {}
-
-    async def scan(
-        self, relative_directory_path: str, on_complete: Callable[[Scan]]
-    ) -> Scan:
-        """Get a scan.
-
-        Scans are created on demand, or returned previously scanned.
-
-        Args:
-            relative_directory_path: A path relative to the root.
-            on_complete: Callback when scan is complete, will be invoked with Scan instance.
-
-        Returns:
-            A scan instance.
-        """
-        scan_path = self.root / relative_directory_path
-        if scan := self.directories.get(scan_path):
-            if scan.is_complete:
-                on_complete(scan)
-        else:
-            self.directories[scan_path] = scan = Scan(
-                scan_path, on_complete=on_complete
-            )
-            scan.start()
-        return scan
-
-
-if __name__ == "__main__":
-    import asyncio
-
-    import contextlib
-    from time import perf_counter
-    from typing import Generator
-
-    @contextlib.contextmanager
-    def timer(subject: str = "time") -> Generator[None, None, None]:
-        """print the elapsed time. (only used in debugging)"""
-        start = perf_counter()
-        yield
-        elapsed = perf_counter() - start
-        elapsed_ms = elapsed
-        print(f"{subject} elapsed {elapsed_ms:.4f}s")
-
-    from tui.path_filter import PathFilter
-
-    scan_path = Path("~/projects/textual").expanduser()
-
-    path_filter = PathFilter.from_git_root(scan_path)
-
-    async def run():
-        with timer("scan"):
-            return await scan(scan_path, path_filter=path_filter)
-
-    paths = asyncio.run(run())
-    print(len(paths))

package/tui/directory_suggester.py

@@ -1,93 +0,0 @@
-import asyncio
-import itertools
-import threading
-from pathlib import Path
-
-from textual.cache import LRUCache
-from textual.suggester import Suggester
-
-
-class ListDirCache:
-    """A cache for listing a directory (not a Rich / Textual object).
-
-    This class is responsible for listing directories, and caching the results.
-
-    Listing a directory is a blocking operation, which is why we defer the work to a thread.
-
-    """
-
-    def __init__(self) -> None:
-        self._cache: LRUCache[tuple[str, int], list[Path]] = LRUCache(100)
-        self._lock = threading.Lock()
-
-    async def listdir(self, path: Path, size: int) -> list[Path]:
-        cache_key = (str(path), size)
-
-        def iterdir_thread(path: Path) -> list[Path]:
-            """Run iterdir in a thread.
-
-            Returns:
-                A list of paths.
-            """
-            return list(itertools.islice(path.iterdir(), size))
-
-        with self._lock:
-            if cache_key in self._cache:
-                paths = self._cache[cache_key]
-            else:
-                paths = await asyncio.to_thread(iterdir_thread, path)
-                self._cache[cache_key] = paths
-            return paths
-
-
-class DirectorySuggester(Suggester):
-    """Suggest a directory.
-
-    This is a [Suggester](https://textual.textualize.io/api/suggester/#textual.suggester.Suggester) instance,
-    used by the Input widget to suggest auto-completions.
-
-    """
-
-    def __init__(self) -> None:
-        self._cache = ListDirCache()
-        super().__init__(case_sensitive=True)
-
-    async def get_suggestion(self, value: str) -> str | None:
-        """Suggest the first matching directory."""
-
-        try:
-            path = Path(value)
-            name = path.name
-
-            children = await self._cache.listdir(
-                path.expanduser() if path.is_dir() else path.parent.expanduser(), 100
-            )
-            possible_paths = [
-                f"{sibling_path}/"
-                for sibling_path in children
-                if sibling_path.name.lower().startswith(name.lower())
-                and sibling_path.is_dir()
-            ]
-            if possible_paths:
-                possible_paths.sort(key=str.__len__)
-                suggestion = possible_paths[0]
-
-                if "~" in value:
-                    home = str(Path("~").expanduser())
-                    suggestion = suggestion.replace(home, "~", 1)
-                return suggestion
-
-        except FileNotFoundError:
-            pass
-        return None
-
-
-if __name__ == "__main__":
-    from textual.app import App, ComposeResult
-    from textual import widgets
-
-    class SApp(App):
-        def compose(self) -> ComposeResult:
-            yield widgets.Input(suggester=DirectorySuggester())
-
-    SApp().run()

package/tui/directory_watcher.py

@@ -1,231 +0,0 @@
-from pathlib import Path
-import rich.repr
-
-import threading
-
-from textual.message import Message
-from textual.widget import Widget
-
-
-from watchdog.events import (
-    FileSystemEvent,
-    FileSystemEventHandler,
-    FileCreatedEvent,
-    FileDeletedEvent,
-    FileMovedEvent,
-    DirCreatedEvent,
-    DirDeletedEvent,
-    DirMovedEvent,
-)
-from watchdog.observers import Observer
-from watchdog.observers.polling import PollingObserver
-
-
-class DirectoryChanged(Message):
-    """The directory was changed."""
-
-    def can_replace(self, message: Message) -> bool:
-        return isinstance(message, DirectoryChanged)
-
-
-_NOISY_DIR_NAMES = frozenset(
-    {
-        ".venv",
-        ".git",
-        ".pytest_cache",
-        "__pycache__",
-        ".mypy_cache",
-        "node_modules",
-        ".uv-cache",
-        "dist",
-        "build",
-        ".idea",
-    }
-)
-
-
-def _is_noisy_path(path: str) -> bool:
-    """Return True when *path* lives inside a directory we want to
-    ignore for change notifications (virtualenvs, caches, build output…).
-    """
-    if not path:
-        return False
-    parts = path.replace("\\", "/").split("/")
-    return any(part in _NOISY_DIR_NAMES for part in parts)
-
-
-class _PathEventDispatcher(FileSystemEventHandler):
-    """Dispatches file system events to multiple DirectoryWatcher instances."""
-
-    def __init__(self, path: Path) -> None:
-        self._path = path
-        self._watchers: set[DirectoryWatcher] = set()
-        self._lock = threading.Lock()
-
-    def add_watcher(self, watcher: "DirectoryWatcher") -> None:
-        """Add a watcher to receive events."""
-        with self._lock:
-            self._watchers.add(watcher)
-
-    def remove_watcher(self, watcher: "DirectoryWatcher") -> None:
-        """Remove a watcher from receiving events."""
-        with self._lock:
-            self._watchers.discard(watcher)
-
-    @property
-    def has_watchers(self) -> bool:
-        """Check if there are any active watchers."""
-        with self._lock:
-            return bool(self._watchers)
-
-    def on_any_event(self, event: FileSystemEvent) -> None:
-        """Dispatch events to all registered watchers.
-
-        Events for paths inside noisy directories (virtualenvs, caches,
-        build output, etc.) are dropped so they don't flood the UI.
-        """
-        src = getattr(event, "src_path", "") or ""
-        dest = getattr(event, "dest_path", "") or ""
-        if _is_noisy_path(src) or _is_noisy_path(dest):
-            return
-        with self._lock:
-            watchers = list(self._watchers)
-
-        for watcher in watchers:
-            watcher.on_any_event(event)
-
-
-class _SharedObserverManager:
-    """Manages shared Observer instances to avoid watchdog's limitation of scheduling the same path multiple times."""
-
-    def __init__(self) -> None:
-        self._observers: dict[Path, tuple[Observer, _PathEventDispatcher]] = {}
-        self._lock = threading.Lock()
-
-    def register(self, path: Path, watcher: "DirectoryWatcher") -> bool:
-        """Register a watcher for a path. Creates a shared observer if needed.
-
-        Args:
-            path: Path to watch.
-            watcher: DirectoryWatcher instance to register.
-
-        Returns:
-            True if successfully registered, False otherwise.
-        """
-        with self._lock:
-            if path in self._observers:
-                # Reuse existing observer and dispatcher for this path
-                observer, dispatcher = self._observers[path]
-                dispatcher.add_watcher(watcher)
-                return True
-
-            # Create a new observer and dispatcher for this path
-            try:
-                observer = Observer()
-            except Exception:
-                return False
-
-            if isinstance(observer, PollingObserver):
-                return False
-
-            dispatcher = _PathEventDispatcher(path)
-            dispatcher.add_watcher(watcher)
-
-            try:
-                observer.schedule(
-                    dispatcher,
-                    str(path),
-                    recursive=True,
-                    event_filter=[
-                        FileCreatedEvent,
-                        FileDeletedEvent,
-                        FileMovedEvent,
-                        DirCreatedEvent,
-                        DirDeletedEvent,
-                        DirMovedEvent,
-                    ],
-                )
-                observer.start()
-            except Exception:
-                return False
-
-            self._observers[path] = (observer, dispatcher)
-            return True
-
-    def unregister(self, path: Path, watcher: "DirectoryWatcher") -> None:
-        """Unregister a watcher. Stops the observer if no more watchers exist for this path.
-
-        Args:
-            path: Path that was being watched.
-            watcher: DirectoryWatcher instance to unregister.
-        """
-        with self._lock:
-            if path not in self._observers:
-                return
-
-            observer, dispatcher = self._observers[path]
-            dispatcher.remove_watcher(watcher)
-
-            # If no more watchers for this path, stop and remove the observer
-            if not dispatcher.has_watchers:
-                try:
-                    observer.stop()
-                    observer.join(timeout=1.0)
-                except Exception:
-                    pass
-                del self._observers[path]
-
-
-# Global singleton instance
-_shared_observer_manager = _SharedObserverManager()
-
-
-@rich.repr.auto
-class DirectoryWatcher(threading.Thread):
-    """Watch for changes to a directory, ignoring purely file data changes.
-
-    Multiple DirectoryWatcher instances can watch the same directory without
-    triggering watchdog's limitation, as they share a single Observer internally.
-    """
-
-    def __init__(self, path: Path, widget: Widget) -> None:
-        """
-
-        Args:
-            path: Root path to monitor.
-            widget: Widget which will receive the `DirectoryChanged` event.
-        """
-        self._path = path.resolve()
-        self._widget = widget
-        self._stop_event = threading.Event()
-        self._enabled = False
-        super().__init__(name=repr(self))
-
-    @property
-    def enabled(self) -> bool:
-        """Is the DirectoryWatcher currently watching?"""
-        return self._enabled
-
-    def on_any_event(self, event: FileSystemEvent) -> None:
-        """Send DirectoryChanged event when the FS is updated.
-
-        Called by the _PathEventDispatcher when file system events occur.
-        """
-        self._widget.post_message(DirectoryChanged())
-
-    def __rich_repr__(self) -> rich.repr.Result:
-        yield self._path
-        yield self._widget
-
-    def run(self) -> None:
-        if not _shared_observer_manager.register(self._path, self):
-            return
-
-        self._enabled = True
-        self._stop_event.wait()
-
-        _shared_observer_manager.unregister(self._path, self)
-
-    def stop(self) -> None:
-        """Stop the watcher."""
-        self._stop_event.set()

package/tui/format_path.py

@@ -1,25 +0,0 @@
-from pathlib import Path
-
-
-def format_path(path: Path | str, directory: bool = False) -> str:
-    """Format a path, using ~/ syntax as approriate.
-
-    Args:
-        path: A path in Path or str form.
-        directory: Format path as a directory (append with separator).
-
-    Returns:
-        Returns a formatted path string.
-    """
-    if isinstance(path, str):
-        path = Path(path)
-    path = path.expanduser().resolve()
-    try:
-        relative = path.relative_to(Path.home())
-        formatted_path = f"~/{relative}"
-    except ValueError:
-        # Path is not relative to home
-        formatted_path = str(path)
-    if directory and not formatted_path.endswith("/"):
-        formatted_path += "/"
-    return formatted_path