@scemoon/cdh 1.0.7 → 1.0.9-beta.1

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

package/tui/fuzzy_index.py

@@ -0,0 +1,275 @@
+import asyncio
+
+from collections import Counter, defaultdict
+from asyncio import Lock
+from itertools import islice
+from operator import itemgetter
+
+
+class FuzzyIndex:
+    """An index for path searching.
+
+    This reduces the number of paths that need to be considered by the relativley expensive scoring function.
+
+    """
+
+    def __init__(self) -> None:
+        self._paths: list[str] = []
+        self._normalized_paths: list[str] = []
+        self._index: dict[str, set[int]] = {}
+        self._weights_cache: dict[str, dict[int, float]] = {}
+        self._path_counter_cache: dict[str, Counter[str]] = {}
+        self._lock = Lock()
+
+    async def update_paths(self, paths: list[str]) -> None:
+        """Update the paths and rebuild the index.
+
+        Args:
+            paths: New paths.
+        """
+        async with self._lock:
+            self._paths = paths
+            self._normalized_paths = await asyncio.to_thread(
+                self._normalize_paths, paths
+            )
+            self._index = await asyncio.to_thread(
+                self._build_trigram_index, self._normalized_paths
+            )
+
+    @classmethod
+    def _normalize_paths(cls, paths: list[str]) -> list[str]:
+        """Normalize the paths for searching.
+
+        Args:
+            paths: List of paths as strings.
+
+        """
+        normalized_paths = list(map(str.casefold, paths))
+        return normalized_paths
+
+    @classmethod
+    def _extract_trigrams(cls, text: str) -> set[str]:
+        """Return the set of all 3-character substrings (trigrams) in text.
+
+        Padding with spaces ensures the start and end of the string are
+        represented, so short strings and prefixes still produce trigrams.
+
+        Args:
+            text: candidate text (path).
+
+        Returns:
+            A set of 3 character strings.
+        """
+        padded = f"  {text} "
+        return {padded[index : index + 3] for index in range(len(padded) - 2)}
+
+    @classmethod
+    def _build_trigram_index(cls, paths: list[str]) -> dict[str, set[int]]:
+        """Build an inverted index mapping each trigram to the indices of paths containing it."""
+        index: dict[str, set[int]] = defaultdict(set)
+        for path_index, path in enumerate(paths):
+            for trigram in cls._extract_trigrams(path):
+                index[trigram].add(path_index)
+        return index
+
+    def _find_candidates(
+        self,
+        query: str,
+        min_trigram_overlap: float = 0.3,
+    ) -> list[tuple[str, str]]:
+        """Return the indices of paths that share enough trigrams with the query.
+
+
+        Args:
+            query: The query to apply to the candidates.
+            min_trigram_overlap: The overlap threshold (default 30%) controls the trade-off between
+                recall (not missing real matches) and how many candidates get passed
+                on to the slower detailed scoring stage.
+
+        """
+        # An upper limit to the number of candidates
+        # If there are this many matches, the user will need to type an additional character or two
+        MAX_CANDIDATES = 2000
+
+        query = query.casefold()
+        query_length = len(query)
+        if query_length == 1:
+            # One character
+            # Find paths which have the query on the first component
+            slash_query = f"/{query}"
+            candidates = list(
+                islice(
+                    (
+                        (path, normalized_path)
+                        for path, normalized_path in zip(
+                            self._paths, self._normalized_paths
+                        )
+                        if (
+                            normalized_path.startswith(query)
+                            or slash_query in normalized_path
+                        )
+                    ),
+                    None,
+                    MAX_CANDIDATES,
+                )
+            )
+            return candidates
+
+        if query_length <= 3:
+            # Find paths which have all the characters
+            query_set = set(query)
+            candidates = list(
+                islice(
+                    (
+                        (path, normalized_path)
+                        for path, normalized_path in zip(
+                            self._paths, self._normalized_paths
+                        )
+                        if query_set.issubset(normalized_path)
+                    ),
+                    None,
+                    MAX_CANDIDATES,
+                )
+            )
+            return candidates
+
+        index = self._index
+        query_trigrams = self._extract_trigrams(query)
+        matching_buckets = [
+            index[trigram] for trigram in query_trigrams if trigram in index
+        ]
+
+        trigram_match_counts = Counter(
+            sorted(path_index for bucket in matching_buckets for path_index in bucket)
+        )
+        minimum_shared_trigrams = len(query_trigrams) * min_trigram_overlap
+        unique_candidates = dict.fromkeys(
+            islice(
+                (
+                    (self._paths[path_index], self._normalized_paths[path_index])
+                    for path_index, count in trigram_match_counts.items()
+                    if count >= minimum_shared_trigrams
+                ),
+                None,
+                MAX_CANDIDATES,
+            )
+        )
+        candidates = list(unique_candidates.keys())
+        return candidates
+
+    @classmethod
+    def make_weights(cls, path: str) -> dict[int, float]:
+        """Assign relative weights to positions with a path.
+
+        Initial characters are weighted more highly, and the last component
+        is weighted higher still.
+
+        Args:
+            path: A path string.
+
+        Returns:
+            A mapping of string indices to relative weights.
+        """
+        weights: dict[int, float] = dict.fromkeys(
+            range(path.rfind("/") + 1, len(path)), 1.0
+        ) | {0: 1.0}
+
+        index = path.find("/", None, -1)
+        while index != -1:
+            weights[index + 1] = weights.setdefault(index + 1, 1.0) + 1.0
+            index = path.find("/", index + 1, -1)
+        return weights
+
+    async def search(self, query: str) -> list[str]:
+
+        normalized_query = query.casefold()
+        query_counter = Counter(normalized_query)
+
+        scores: list[tuple[float, str]] = []
+
+        TOP_COUNT = 1000
+
+        async with self._lock:
+            for path, normalized_path in self._find_candidates(normalized_query):
+                if (
+                    path_counter := self._path_counter_cache.get(normalized_path)
+                ) is None:
+                    path_counter = self._path_counter_cache[normalized_path] = Counter(
+                        normalized_path
+                    )
+                if query_counter - path_counter:
+                    # Not all query characters are matched in the path
+                    continue
+
+                if (weights := self._weights_cache.get(normalized_path)) is None:
+                    weights = self._weights_cache[normalized_path] = self.make_weights(
+                        normalized_path
+                    )
+
+                score = sum(
+                    [
+                        weights.get(normalized_query.rfind(character), 0.0)
+                        for character in normalized_path
+                    ]
+                )
+                if normalized_path.endswith(normalized_query):
+                    score *= 2
+                if normalized_path.endswith(f"/{normalized_query}"):
+                    score *= 2
+                scores.append((score, path))
+
+            scores.sort(reverse=True)
+            top_scores = scores[:TOP_COUNT]
+
+            return list(map(itemgetter(1), top_scores))
+
+
+if __name__ == "__main__":
+
+    # from textual._profile import timer
+
+    from time import perf_counter
+    import contextlib
+    from typing import Generator
+
+    @contextlib.contextmanager
+    def timer(
+        subject: str = "time", threshold: float = 0
+    ) -> Generator[None, None, None]:
+        """print the elapsed time. (only used in debugging).
+
+        Args:
+            subject: Text shown in log.
+            threshold: Time in second after which the log is written.
+
+        """
+        start = perf_counter()
+        yield
+        elapsed = perf_counter() - start
+        if elapsed >= threshold:
+            elapsed_ms = elapsed * 1000
+            print(f"{subject} elapsed {elapsed_ms:.4f}ms")
+
+    async def run():
+        with open("paths.txt") as f:
+            PATHS = [line.rstrip() for line in f.readlines()]
+        print(len(PATHS))
+        # PATHS = [
+        #     "~/foo/",
+        #     "~/foo/bar/",
+        #     "~/foo/bar/baz",
+        #     "~/worldhello/foo",
+        #     "~/Hello/world",
+        # ]
+        fuzzy = FuzzyIndex()
+        with timer("update"):
+            await fuzzy.update_paths(PATHS)
+        with timer("search"):
+            scores = await fuzzy.search("LICE")
+        import rich
+
+        rich.print(scores)
+
+    import asyncio
+
+    asyncio.run(run())

package/tui/gist.py

@@ -0,0 +1,33 @@
+import httpx
+
+
+# This doesn't work anonymously
+# TODO: Implement login
+def create_gist(
+    files: dict[str, str],
+    description: str = "",
+    public: bool = True,
+) -> str:
+    """Create a GitHub Gist and return its URL.
+
+    Args:
+        files: A mapping of filename to file content.
+        description: An optional description for the gist.
+        public: Whether the gist should be public.
+
+    Returns:
+        The URL of the created gist.
+    """
+    payload = {
+        "description": description,
+        "public": public,
+        "files": {name: {"content": content} for name, content in files.items()},
+    }
+
+    response = httpx.post(
+        "https://api.github.com/gists",
+        json=payload,
+        headers={"Accept": "application/vnd.github+json"},
+    )
+    response.raise_for_status()
+    return response.json()["html_url"]

package/tui/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 tui.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