@scemoon/cdh 1.0.0

package/tui/directory.py

@@ -0,0 +1,234 @@
+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

@@ -0,0 +1,93 @@
+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

@@ -0,0 +1,197 @@
+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)
+
+
+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."""
+        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

@@ -0,0 +1,25 @@
+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

package/tui/fuzzy.py

@@ -0,0 +1,140 @@
+"""
+Fuzzy matcher.
+
+This class is used by the [command palette](/guide/command_palette) to match search terms.
+
+"""
+
+from __future__ import annotations
+
+from functools import lru_cache
+from operator import itemgetter
+from re import finditer
+from typing import Iterable, Sequence
+
+
+from textual.cache import LRUCache
+
+
+class FuzzySearch:
+    """Performs a fuzzy search.
+
+    Unlike a regex solution, this will finds all possible matches.
+    """
+
+    def __init__(
+        self, case_sensitive: bool = False, *, cache_size: int = 1024 * 4
+    ) -> None:
+        """Initialize fuzzy search.
+
+        Args:
+            case_sensitive: Is the match case sensitive?
+            cache_size: Number of queries to cache.
+        """
+
+        self.case_sensitive = case_sensitive
+        self.cache: LRUCache[tuple[str, str], tuple[float, Sequence[int]]] = LRUCache(
+            cache_size
+        )
+
+    def match(self, query: str, candidate: str) -> tuple[float, Sequence[int]]:
+        """Match against a query.
+
+        Args:
+            query: The fuzzy query.
+            candidate: A candidate to check,.
+
+        Returns:
+            A pair of (score, tuple of offsets). `(0, ())` for no result.
+        """
+
+        cache_key = (query, candidate)
+        if cache_key in self.cache:
+            return self.cache[cache_key]
+        default: tuple[float, Sequence[int]] = (0.0, [])
+        result = max(self._match(query, candidate), key=itemgetter(0), default=default)
+        self.cache[cache_key] = result
+        return result
+
+    @classmethod
+    @lru_cache(maxsize=1024)
+    def get_first_letters(cls, candidate: str) -> frozenset[int]:
+        return frozenset({match.start() for match in finditer(r"\w+", candidate)})
+
+    def score(self, candidate: str, positions: Sequence[int]) -> float:
+        """Score a search.
+
+        Args:
+            search: Search object.
+
+        Returns:
+            Score.
+        """
+
+        first_letters = self.get_first_letters(candidate)
+        # This is a heuristic, and can be tweaked for better results
+        # Boost first letter matches
+        offset_count = len(positions)
+        score: float = offset_count + len(first_letters.intersection(positions))
+
+        groups = 1
+        last_offset, *offsets = positions
+        for offset in offsets:
+            if offset != last_offset + 1:
+                groups += 1
+            last_offset = offset
+
+        # Boost to favor less groups
+        normalized_groups = (offset_count - (groups - 1)) / offset_count
+        score *= 1 + (normalized_groups * normalized_groups)
+        return score
+
+    def _match(
+        self, query: str, candidate: str
+    ) -> Iterable[tuple[float, Sequence[int]]]:
+        letter_positions: list[list[int]] = []
+        position = 0
+
+        if not self.case_sensitive:
+            candidate = candidate.casefold()
+            query = query.casefold()
+
+        score = self.score
+
+        for offset, letter in enumerate(query):
+            last_index = len(candidate) - offset
+            positions: list[int] = []
+            letter_positions.append(positions)
+            index = position
+            while (location := candidate.find(letter, index)) != -1:
+                positions.append(location)
+                index = location + 1
+                if index >= last_index:
+                    break
+            if not positions:
+                yield (0.0, ())
+                return
+            position = positions[0] + 1
+
+        possible_offsets: list[list[int]] = []
+        query_length = len(query)
+
+        def get_offsets(offsets: list[int], positions_index: int) -> None:
+            """Recursively match offsets.
+
+            Args:
+                offsets: A list of offsets.
+                positions_index: Index of query letter.
+
+            """
+            for offset in letter_positions[positions_index]:
+                if not offsets or offset > offsets[-1]:
+                    new_offsets = [*offsets, offset]
+                    if len(new_offsets) == query_length:
+                        possible_offsets.append(new_offsets)
+                    else:
+                        get_offsets(new_offsets, positions_index + 1)
+
+        get_offsets([], 0)
+        for offsets in possible_offsets:
+            yield score(candidate, offsets), offsets