omdev 0.0.0.dev463__py3-none-any.whl → 0.0.0.dev465__py3-none-any.whl

omdev/tui/textual/autocomplete/__init__.py

@@ -0,0 +1,33 @@
+# MIT License
+#
+# Copyright (c) 2023 Darren Burns
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+# https://github.com/darrenburns/textual-autocomplete/tree/0344cd3eb3383cbbd80e01b035ed808ce53cef4d
+from .matching import (  # noqa
+    FuzzySearch,
+    FuzzyMatcher,
+)
+
+from .paths import (  # noqa
+    PathAutoComplete,
+)
+
+from .widget import (  # noqa
+    AutoCompleteItem,
+    AutoCompleteItemHit,
+    AutoCompleteList,
+    AutoComplete,
+)

omdev/tui/textual/autocomplete/matching.py

@@ -0,0 +1,226 @@
+import functools
+import operator
+import re
+import typing as ta
+
+import rich.repr
+from textual.cache import LRUCache
+from textual.content import Content
+from textual.style import Style
+
+
+##
+
+
+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, ta.Sequence[int]]] = LRUCache(cache_size)
+
+    def match(self, query: str, candidate: str) -> tuple[float, ta.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, ta.Sequence[int]] = (0.0, [])
+        result = max(self._match(query, candidate), key=operator.itemgetter(0), default=default)
+        self.cache[cache_key] = result
+        return result
+
+    @classmethod
+    @functools.lru_cache(maxsize=1024)
+    def get_first_letters(cls, candidate: str) -> frozenset[int]:
+        return frozenset({match.start() for match in re.finditer(r'\w+', candidate)})
+
+    def score(self, candidate: str, positions: ta.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) -> ta.Iterable[tuple[float, ta.Sequence[int]]]:
+        letter_positions: list[list[int]] = []
+        position = 0
+
+        if not self.case_sensitive:
+            candidate = candidate.lower()
+            query = query.lower()
+        score = self.score
+        if query in candidate:
+            # Quick exit when the query exists as a substring
+            query_location = candidate.rfind(query)
+            offsets = list(range(query_location, query_location + len(query)))
+            yield (
+                score(candidate, offsets) * (2.0 if candidate == query else 1.5),
+                offsets,
+            )
+            return
+
+        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
+
+
+@rich.repr.auto
+class FuzzyMatcher:
+    """A fuzzy matcher."""
+
+    def __init__(
+            self,
+            query: str,
+            *,
+            match_style: Style | None = None,
+            case_sensitive: bool = False,
+    ) -> None:
+        """
+        Initialize the fuzzy matching object.
+
+        Args:
+            query: A query as typed in by the user.
+            match_style: The style to use to highlight matched portions of a string.
+            case_sensitive: Should matching be case sensitive?
+        """
+
+        self._query = query
+        self._match_style = Style(reverse=True) if match_style is None else match_style
+        self._case_sensitive = case_sensitive
+        self.fuzzy_search = FuzzySearch()
+
+    @property
+    def query(self) -> str:
+        """The query string to look for."""
+
+        return self._query
+
+    @property
+    def match_style(self) -> Style:
+        """The style that will be used to highlight hits in the matched text."""
+
+        return self._match_style
+
+    @property
+    def case_sensitive(self) -> bool:
+        """Is this matcher case sensitive?"""
+
+        return self._case_sensitive
+
+    def match(self, candidate: str) -> float:
+        """
+        Match the candidate against the query.
+
+        Args:
+            candidate: Candidate string to match against the query.
+
+        Returns:
+            Strength of the match from 0 to 1.
+        """
+
+        return self.fuzzy_search.match(self.query, candidate)[0]
+
+    def highlight(self, candidate: str) -> Content:
+        """
+        Highlight the candidate with the fuzzy match.
+
+        Args:
+            candidate: The candidate string to match against the query.
+
+        Returns:
+            A [`Text`][rich.text.Text] object with highlighted matches.
+        """
+
+        content = Content.from_markup(candidate)
+        score, offsets = self.fuzzy_search.match(self.query, candidate)
+        if not score:
+            return content
+        for offset in offsets:
+            if not candidate[offset].isspace():
+                content = content.stylize(self._match_style, offset, offset + 1)
+        return content

omdev/tui/textual/autocomplete/paths.py

@@ -0,0 +1,202 @@
+import os
+import pathlib
+import typing as ta
+
+from textual.cache import LRUCache
+from textual.content import Content
+from textual.widgets import Input
+
+from .widget import AutoComplete
+from .widget import AutoCompleteItem
+
+
+##
+
+
+class PathAutoCompleteItem(AutoCompleteItem):
+    def __init__(self, completion: str, path: pathlib.Path) -> None:
+        super().__init__(completion)
+
+        self.path = path
+
+
+def default_path_input_sort_key(item: PathAutoCompleteItem) -> tuple[bool, bool, str]:
+    """
+    Sort key function for results within the dropdown.
+
+    Args:
+        item: The PathAutoCompleteItem to get a sort key for.
+
+    Returns:
+        A tuple of (is_dotfile, is_file, lowercase_name) for sorting.
+    """
+
+    name = item.path.name
+    is_dotfile = name.startswith('.')
+    return (not item.path.is_dir(), not is_dotfile, name.lower())
+
+
+class PathAutoComplete(AutoComplete):
+    def __init__(
+            self,
+            target: Input | str,
+            path: str | pathlib.Path = '.',
+            *,
+            show_dotfiles: bool = True,
+            sort_key: ta.Callable[[PathAutoCompleteItem], ta.Any] = default_path_input_sort_key,
+            folder_prefix: Content = Content('📂'),
+            file_prefix: Content = Content('📄'),
+            prevent_default_enter: bool = True,
+            prevent_default_tab: bool = True,
+            cache_size: int = 100,
+            name: str | None = None,
+            id: str | None = None,  # noqa
+            classes: str | None = None,
+            disabled: bool = False,
+    ) -> None:
+        """
+        An autocomplete widget for filesystem paths.
+
+        Args:
+            target: The target input widget to autocomplete.
+            path: The base path to autocomplete from.
+            show_dotfiles: Whether to show dotfiles (files/dirs starting with ".").
+            sort_key: Function to sort the dropdown items.
+            folder_prefix: The prefix for folder items (e.g. 📂).
+            file_prefix: The prefix for file items (e.g. 📄).
+            prevent_default_enter: Whether to prevent the default enter behavior.
+            prevent_default_tab: Whether to prevent the default tab behavior.
+            cache_size: The number of directories to cache.
+            name: The name of the widget.
+            id: The DOM node id of the widget.
+            classes: The CSS classes of the widget.
+            disabled: Whether the widget is disabled.
+        """
+
+        super().__init__(
+            target,
+            None,
+            prevent_default_enter=prevent_default_enter,
+            prevent_default_tab=prevent_default_tab,
+            name=name,
+            id=id,
+            classes=classes,
+            disabled=disabled,
+        )
+
+        self.path = pathlib.Path(path) if isinstance(path, str) else path
+        self.show_dotfiles = show_dotfiles
+        self.sort_key = sort_key
+        self.folder_prefix = folder_prefix
+        self.file_prefix = file_prefix
+        self._directory_cache: LRUCache[str, list[os.DirEntry[str]]] = LRUCache(cache_size)
+
+    def get_candidates(self, target_state: AutoComplete.TargetState) -> list[AutoCompleteItem]:
+        """
+        Get the candidates for the current path segment.
+
+        This is called each time the input changes or the cursor position changes/
+        """
+
+        current_input = target_state.text[: target_state.cursor_position]
+
+        if '/' in current_input:
+            last_slash_index = current_input.rindex('/')
+            path_segment = current_input[:last_slash_index] or '/'
+            directory = self.path / path_segment if path_segment != '/' else self.path
+        else:
+            directory = self.path
+
+        # Use the directory path as the cache key
+        cache_key = str(directory)
+        cached_entries = self._directory_cache.get(cache_key)
+
+        if cached_entries is not None:
+            entries = cached_entries
+        else:
+            try:
+                entries = list(os.scandir(directory))
+                self._directory_cache[cache_key] = entries
+            except OSError:
+                return []
+
+        results: list[PathAutoCompleteItem] = []
+        for entry in entries:
+            # Only include the entry name, not the full path
+            completion = entry.name
+            if not self.show_dotfiles and completion.startswith('.'):
+                continue
+            if entry.is_dir():
+                completion += '/'
+            results.append(PathAutoCompleteItem(completion, path=pathlib.Path(entry.path)))
+
+        results.sort(key=self.sort_key)
+        folder_prefix = self.folder_prefix
+        file_prefix = self.file_prefix
+        return [
+            AutoCompleteItem(
+                item.main,
+                prefix=folder_prefix if item.path.is_dir() else file_prefix,
+            )
+            for item in results
+        ]
+
+    def get_search_string(self, target_state: AutoComplete.TargetState) -> str:
+        """Return only the current path segment for searching in the dropdown."""
+
+        current_input = target_state.text[: target_state.cursor_position]
+
+        if '/' in current_input:
+            last_slash_index = current_input.rindex('/')
+            search_string = current_input[last_slash_index + 1:]
+            return search_string
+        else:
+            return current_input
+
+    def apply_completion(self, value: str, state: AutoComplete.TargetState) -> None:
+        """Apply the completion by replacing only the current path segment."""
+
+        target = self.target
+        current_input = state.text
+        cursor_position = state.cursor_position
+
+        # There's a slash before the cursor, so we only want to replace the text after the last slash with the selected
+        # value
+        try:
+            replace_start_index = current_input.rindex('/', 0, cursor_position)
+        except ValueError:
+            # No slashes, so we do a full replacement
+            new_value = value
+            new_cursor_position = len(value)
+        else:
+            # Keep everything before and including the slash before the cursor.
+            path_prefix = current_input[: replace_start_index + 1]
+            new_value = path_prefix + value
+            new_cursor_position = len(path_prefix) + len(value)
+
+        with self.prevent(Input.Changed):
+            target.value = new_value
+            target.cursor_position = new_cursor_position
+
+    def post_completion(self) -> None:
+        if not self.target.value.endswith('/'):
+            self.action_hide()
+
+    def should_show_dropdown(self, search_string: str) -> bool:
+        return (
+            super().should_show_dropdown(search_string) or
+            (
+                (search_string == '' and self.target.value != '') and
+                self.option_list.option_count > 1
+            )
+        )
+
+    def clear_directory_cache(self) -> None:
+        """
+        Clear the directory cache. If you know that the contents of the directory have changed, you can call this method
+        to invalidate the cache.
+        """
+
+        self._directory_cache.clear()
+        target_state = self._get_target_state()
+        self._rebuild_options(target_state, self.get_search_string(target_state))