batrachian-toad 0.5.22__py3-none-any.whl

toad/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 toad.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 toad.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))

toad/directory_watcher.py

@@ -0,0 +1,96 @@
+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)
+
+
+@rich.repr.auto
+class DirectoryWatcher(threading.Thread, FileSystemEventHandler):
+    """Watch for changes to a directory, ignoring purely file data changes."""
+
+    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
+        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."""
+        self._widget.post_message(DirectoryChanged())
+
+    def __rich_repr__(self) -> rich.repr.Result:
+        yield self._path
+        yield self._widget
+
+    def run(self) -> None:
+        try:
+            observer = Observer()
+        except Exception:
+            return
+        if isinstance(observer, PollingObserver):
+            return
+        try:
+            observer.schedule(
+                self,
+                str(self._path),
+                recursive=True,
+                event_filter=[
+                    FileCreatedEvent,
+                    FileDeletedEvent,
+                    FileMovedEvent,
+                    DirCreatedEvent,
+                    DirDeletedEvent,
+                    DirMovedEvent,
+                ],
+            )
+            observer.start()
+        except Exception:
+            return
+        self._enabled = True
+        while not self._stop_event.wait(1):
+            pass
+        try:
+            observer.stop()
+        except Exception:
+            pass
+
+    def stop(self) -> None:
+        """Stop the watcher."""
+
+        self._stop_event.set()

toad/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 re2 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.lower()
+            query = query.lower()
+
+        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

toad/gist.py

@@ -0,0 +1,2 @@
+async def upload(content: str) -> None:
+    pass

toad/history.py

@@ -0,0 +1,138 @@
+from typing import TypedDict
+import asyncio
+import json
+from pathlib import Path
+from time import time
+
+import rich.repr
+
+from toad.complete import Complete
+
+
+class HistoryEntry(TypedDict):
+    """An entry in the history file."""
+
+    input: str
+    timestamp: float
+
+
+@rich.repr.auto
+class History:
+    """Manages a history file."""
+
+    def __init__(self, path: Path) -> None:
+        self.path = path
+        self._lines: list[str] = []
+        self._opened: bool = False
+        self._current: str | None = None
+        self.complete = Complete()
+
+    def __rich_repr__(self) -> rich.repr.Result:
+        yield self.path
+
+    @property
+    def current(self) -> str | None:
+        return self._current
+
+    @current.setter
+    def current(self, current: str) -> None:
+        self._current = current
+
+    @property
+    def size(self) -> int:
+        return len(self._lines)
+
+    async def open(self) -> bool:
+        """Open the history file, read initial lines.
+
+        Returns:
+            `True` if lines were read, otherwise `False`.
+        """
+        if self._opened:
+            return True
+
+        def read_history() -> bool:
+            """Read the history file (in a thread).
+
+            Returns:
+                `True` on success.
+            """
+            try:
+                self.path.touch(exist_ok=True)
+                with self.path.open("r") as history_file:
+                    self._lines = history_file.readlines()
+
+                inputs: list[str] = []
+                for line in self._lines:
+                    if (input := json.loads(line).get("input")) is not None:
+                        inputs.append(input.split(" ", 1)[0])
+                self.complete.add_words(inputs)
+            except Exception:
+                return False
+            return True
+
+        self._opened = await asyncio.to_thread(read_history)
+        return self._opened
+
+    async def append(self, input: str) -> bool:
+        """Append a history entry.
+
+        Args:
+            text: Text in the history.
+            shell: Boolean that indicates if the text is shell (`True`) or prompt (`False`).
+
+        Returns:
+            `True` on success.
+        """
+
+        if not input:
+            return True
+        self.complete.add_words([input.split(" ")[0]])
+
+        def write_line() -> bool:
+            """Append a line to the history.
+
+            Returns:
+                `True` on success, `False` if write failed.
+            """
+            history_entry: HistoryEntry = {
+                "input": input,
+                "timestamp": time(),
+            }
+            line = json.dumps(history_entry)
+            self._lines.append(line)
+            try:
+                with self.path.open("a") as history_file:
+                    history_file.write(f"{line}\n")
+            except Exception:
+                return False
+            self._current = None
+            return True
+
+        if not self._opened:
+            await self.open()
+
+        return await asyncio.to_thread(write_line)
+
+    async def get_entry(self, index: int) -> HistoryEntry:
+        """Get a history entry via its index.
+
+        Args:
+            index: Index of entry. 0 for the last entry, negative indexes for previous entries.
+
+        Returns:
+            A history entry dict.
+        """
+        if index > 0:
+            raise IndexError("History indices must be 0 or negative.")
+        if not self._opened:
+            await self.open()
+
+        if index == 0:
+            return {"input": self.current or "", "timestamp": time()}
+        try:
+            entry_line = self._lines[index]
+        except IndexError:
+            raise IndexError(f"No history entry at index {index}")
+        history_entry: HistoryEntry = json.loads(entry_line)
+        return history_entry