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

omdev/tui/rich/__init__.py

@@ -9,6 +9,7 @@ with _lang.auto_proxy_init(globals()):
     from rich import console  # noqa
     from rich import live  # noqa
     from rich import markdown  # noqa
+    from rich import repr  # noqa
     from rich import text  # noqa
     from rich.console import Console  # noqa
     from rich.live import Live  # noqa

omdev/tui/textual/__init__.py

@@ -8,13 +8,16 @@ with _lang.auto_proxy_init(globals()):
 
     from textual import app  # noqa
     from textual import binding  # noqa
+    from textual import constants  # noqa
     from textual import containers  # noqa
     from textual import content  # noqa
     from textual import driver  # noqa
     from textual import events  # noqa
+    from textual import geometry  # noqa
     from textual import markup  # noqa
     from textual import message  # noqa
     from textual import messages  # noqa
+    from textual import on  # noqa
     from textual import pad  # noqa
     from textual import reactive  # noqa
     from textual import screen  # noqa
@@ -116,6 +119,16 @@ with _lang.auto_proxy_init(globals()):
     from textual.events import Show  # noqa
     from textual.events import Timer as TimerEvent  # noqa
     from textual.events import Unmount  # noqa
+    from textual.geometry import NULL_OFFSET  # noqa
+    from textual.geometry import NULL_REGION  # noqa
+    from textual.geometry import NULL_SIZE  # noqa
+    from textual.geometry import NULL_SPACING  # noqa
+    from textual.geometry import Offset  # noqa
+    from textual.geometry import Region  # noqa
+    from textual.geometry import Size  # noqa
+    from textual.geometry import Spacing  # noqa
+    from textual.geometry import SpacingDimensions  # noqa
+    from textual.geometry import clamp  # noqa
     from textual.markup import MarkupError  # noqa
     from textual.markup import MarkupTokenizer  # noqa
     from textual.markup import StyleTokenizer  # noqa
@@ -197,6 +210,9 @@ with _lang.auto_proxy_init(globals()):
     from textual.widgets import Tooltip  # noqa
     from textual.widgets import Tree  # noqa
     from textual.widgets import Welcome  # noqa
+    from textual.widgets.option_list import OptionDoesNotExist  # noqa
+    from textual.widgets.option_list import Option  # noqa
+    from textual.widgets.option_list import DuplicateID  # noqa
 
     ##
 

omdev/tui/textual/autocomplete/LICENSE

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

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))

omdev/tui/textual/autocomplete/widget.py

@@ -0,0 +1,612 @@
+import dataclasses as dc
+import operator
+import typing as ta
+
+from rich.text import Text
+from textual import events
+from textual import on
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.binding import BindingType
+from textual.content import Content
+from textual.css.query import NoMatches
+from textual.geometry import Offset
+from textual.geometry import Region
+from textual.geometry import Spacing
+from textual.style import Style
+from textual.widget import Widget
+from textual.widgets import Input
+from textual.widgets import OptionList
+from textual.widgets.option_list import Option
+
+from omlish import check
+
+from .matching import FuzzySearch
+
+
+##
+
+
+class AutoCompleteItem(Option):
+    def __init__(
+            self,
+            main: str | Content,
+            prefix: str | Content | None = None,
+            id: str | None = None,  # noqa
+            disabled: bool = False,
+    ) -> None:
+        """
+        A single option appearing in the autocompletion dropdown. Each option has up to 3 columns. Note that this is not
+        a widget, it's simply a data structure for describing dropdown items.
+
+        Args:
+            prefix: The prefix will often contain an icon/symbol, the main (middle) column contains the text that
+                represents this option.
+            main: The main text representing this option - this will be highlighted by default. In an IDE, the `main`
+                (middle) column might contain the name of a function or method.
+        """
+
+        self.main = Content(main) if isinstance(main, str) else main
+        self.prefix = Content(prefix) if isinstance(prefix, str) else prefix
+        left = self.prefix
+        prompt = self.main
+        if left:
+            prompt = Content.assemble(left, self.main)
+
+        super().__init__(prompt, id, disabled)
+
+    @property
+    def value(self) -> str:
+        return self.main.plain
+
+
+class AutoCompleteItemHit(AutoCompleteItem):
+    """
+    A dropdown item which matches the current search string - in other words AutoComplete.match has returned a score
+    greater than 0 for this item.
+    """
+
+
+class AutoCompleteList(OptionList):
+    pass
+
+
+class AutoComplete(Widget):
+    BINDINGS: ta.ClassVar[list[BindingType]] = [
+        Binding('escape', 'hide', 'Hide dropdown', show=False),
+    ]
+
+    DEFAULT_CSS = """
+    AutoComplete {
+        height: auto;
+        width: auto;
+        max-height: 12;
+        display: none;
+        background: $surface;
+        overlay: screen;
+
+        & AutoCompleteList {
+            width: auto;
+            height: auto;
+            border: none;
+            padding: 0;
+            margin: 0;
+            scrollbar-size-vertical: 1;
+            text-wrap: nowrap;
+            color: $foreground;
+            background: transparent;
+        }
+
+        & .autocomplete--highlight-match {
+            text-style: bold;
+        }
+
+    }
+    """
+
+    COMPONENT_CLASSES: ta.ClassVar[set[str]] = {
+        'autocomplete--highlight-match',
+    }
+
+    class Matcher(ta.Protocol):
+        def __call__(self, query: str, candidate: str) -> tuple[float, ta.Sequence[int]]:
+            """
+            Match a query (search string) against a candidate (dropdown item value).
+
+            Returns a tuple of (score, offsets) where score is a float between 0 and 1, used for sorting the matches,
+            and offsets is a tuple of integers representing the indices of the characters in the candidate string that
+            match the query.
+            """
+
+            ...
+
+    @dc.dataclass()
+    class TargetState:
+        text: str
+        """The content in the target widget."""
+
+        cursor_position: int
+        """The cursor position in the target widget."""
+
+    def __init__(
+            self,
+            target: Input | str,
+            candidates: ta.Sequence[AutoCompleteItem | str] | ta.Callable[[TargetState], list[AutoCompleteItem]] | None = None,  # noqa
+            *,
+            prevent_default_enter: bool = True,
+            prevent_default_tab: bool = True,
+            name: str | None = None,
+            id: str | None = None,  # noqa
+            classes: str | None = None,
+            disabled: bool = False,
+            matcher: Matcher | None = None,
+    ) -> None:
+        """
+        An autocomplete widget.
+
+        Args:
+            target: An Input instance or a selector string used to query an Input instance. If a selector is used,
+                remember that widgets are not available until the widget has been mounted (don't use the selector in
+                `compose` - use it in `on_mount` instead).
+            candidates: The candidates to match on, or a function which returns the candidates to match on. If set to
+                None, the candidates will be fetched by directly calling the `get_candidates` method, which is what
+                you'll probably want to do if you're subclassing AutoComplete and supplying your own custom
+                `get_candidates` method.
+            prevent_default_enter: Prevent the default enter behavior. If True, when you select a dropdown option using
+                the enter key, the default behavior (e.g. submitting an Input) will be prevented.
+            prevent_default_tab: Prevent the default tab behavior. If True, when you select a dropdown option using the
+                tab key, the default behavior (e.g. moving focus to the next widget) will be prevented.
+        """
+
+        super().__init__(name=name, id=id, classes=classes, disabled=disabled)
+
+        self._target = target
+
+        # Users can supply strings as a convenience for the simplest cases, so let's convert them to DropdownItems.
+        if isinstance(candidates, ta.Sequence):
+            self.candidates = [
+                candidate
+                if isinstance(candidate, AutoCompleteItem)
+                else AutoCompleteItem(main=candidate)
+                for candidate in candidates
+            ]
+        else:
+            self.candidates = candidates
+
+        self.prevent_default_enter = prevent_default_enter
+        self.prevent_default_tab = prevent_default_tab
+        self._target_state = AutoComplete.TargetState('', 0)
+        self._previous_terminal_cursor_position = (0, 0)
+        if matcher is None:
+            matcher = FuzzySearch().match
+        self._matcher = matcher
+
+    candidates: list[AutoCompleteItem] | ta.Callable[[TargetState], list[AutoCompleteItem]] | None
+    """The candidates to match on, or a function which returns the candidates to match on."""
+
+    prevent_default_enter: bool
+    """
+    Prevent the default enter behavior. If True, when you select a dropdown option using the enter key, the default
+    behavior (e.g. submitting an Input) will be prevented.
+    """
+
+    prevent_default_tab: bool
+    """
+    Prevent the default tab behavior. If True, when you select a dropdown option using the tab key, the default
+    behavior (e.g. moving focus to the next widget) will be prevented.
+    """
+
+    _target_state: TargetState
+    """Cached state of the target Input."""
+
+    _matcher: Matcher
+    """The default implementation used by AutoComplete.match."""
+
+    _previous_terminal_cursor_position: tuple[int, int]
+    """Tracks the last known cursor position in the terminal."""
+
+    def compose(self) -> ComposeResult:
+        option_list = AutoCompleteList()
+        option_list.can_focus = False
+        yield option_list
+
+    def on_mount(self) -> None:
+        # Subscribe to the target widget's reactive attributes.
+        self.target.message_signal.subscribe(self, self._listen_to_messages)  # type: ignore
+        self._subscribe_to_target()
+        self._handle_target_update()
+
+        def _realign(_=None) -> None:
+            # Only realign if the cursor position has changed (the cursor position is in screen-space, so if it remains
+            # the same, the autocomplete does not need to be realigned).
+            if (
+                    self.is_attached and
+                    self._previous_terminal_cursor_position != self.app.cursor_position
+            ):
+                self._align_to_target()
+                self._previous_terminal_cursor_position = self.app.cursor_position
+
+        self.screen.screen_layout_refresh_signal.subscribe(self, _realign)
+
+    def _listen_to_messages(self, event: events.Event) -> None:
+        """Listen to some events of the target widget."""
+
+        try:
+            option_list = self.option_list
+        except NoMatches:
+            # This can happen if the event is an Unmount event during application shutdown.
+            return
+
+        if isinstance(event, events.Key) and option_list.option_count:
+            displayed = self.display
+            highlighted = option_list.highlighted or 0
+            if event.key == 'down':
+                # Check if there's only one item and it matches the search string
+                if option_list.option_count == 1:
+                    search_string = self.get_search_string(self._get_target_state())
+                    first_option = option_list.get_option_at_index(0).prompt
+                    text_from_option = (
+                        first_option.plain
+                        if isinstance(first_option, Text)
+                        else first_option
+                    )
+                    if text_from_option == search_string:
+                        # Don't prevent default behavior in this case
+                        return
+
+                # If you press `down` while in an Input and the autocomplete is currently hidden, then we should show
+                # the dropdown.
+                event.prevent_default()
+                event.stop()
+                if displayed:
+                    highlighted = (highlighted + 1) % option_list.option_count
+                else:
+                    self.display = True
+                    highlighted = 0
+
+                option_list.highlighted = highlighted
+
+            elif event.key == 'up':
+                if displayed:
+                    event.prevent_default()
+                    event.stop()
+                    highlighted = (highlighted - 1) % option_list.option_count
+                    option_list.highlighted = highlighted
+
+            elif event.key == 'enter':
+                if self.prevent_default_enter and displayed:
+                    event.prevent_default()
+                    event.stop()
+                self._complete(option_index=highlighted)
+
+            elif event.key == 'tab':
+                if self.prevent_default_tab and displayed:
+                    event.prevent_default()
+                    event.stop()
+                self._complete(option_index=highlighted)
+
+            elif event.key == 'escape':
+                if displayed:
+                    event.prevent_default()
+                    event.stop()
+                self.action_hide()
+
+        if isinstance(event, Input.Changed):
+            # We suppress Changed events from the target widget, so that we don't handle change events as a result of
+            # performing a completion.
+            self._handle_target_update()
+
+    def action_hide(self) -> None:
+        self.styles.display = 'none'
+
+    def action_show(self) -> None:
+        self.styles.display = 'block'
+
+    def _complete(self, option_index: int) -> None:
+        """
+        Do the completion (i.e. insert the selected item into the target input).
+
+        This is when the user highlights an option in the dropdown and presses tab or enter.
+        """
+
+        if not self.display or self.option_list.option_count == 0:
+            return
+
+        option_list = self.option_list
+        highlighted = option_index
+        option = ta.cast(AutoCompleteItem, option_list.get_option_at_index(highlighted))
+        highlighted_value = option.value
+        with self.prevent(Input.Changed):
+            self.apply_completion(highlighted_value, self._get_target_state())
+        self.post_completion()
+
+    def post_completion(self) -> None:
+        """This method is called after a completion is applied. By default, it simply hides the dropdown."""
+
+        self.action_hide()
+
+    def apply_completion(self, value: str, state: TargetState) -> None:
+        """
+        Apply the completion to the target widget.
+
+        This method updates the state of the target widget to the reflect the value the user has chosen from the
+        dropdown list.
+        """
+
+        target = self.target
+        target.value = ''
+        target.insert_text_at_cursor(value)
+
+        # We need to rebuild here because we've prevented the Changed events from being sent to the target widget,
+        # meaning AutoComplete won't spot intercept that message, and would not trigger a rebuild like it normally does
+        # when a Changed event is received.
+        new_target_state = self._get_target_state()
+        self._rebuild_options(new_target_state, self.get_search_string(new_target_state))
+
+    @property
+    def target(self) -> Input:
+        """The resolved target widget."""
+
+        if isinstance(self._target, Input):
+            return self._target
+
+        else:
+            target = self.screen.query_one(self._target)
+            return check.isinstance(target, Input)
+
+    def _subscribe_to_target(self) -> None:
+        """Attempt to subscribe to the target widget, if it's available."""
+
+        target = self.target
+        self.watch(target, 'has_focus', self._handle_focus_change)
+        self.watch(target, 'selection', self._align_and_rebuild)
+
+    def _align_and_rebuild(self) -> None:
+        self._align_to_target()
+        self._target_state = self._get_target_state()
+        search_string = self.get_search_string(self._target_state)
+        self._rebuild_options(self._target_state, search_string)
+
+    def _align_to_target(self) -> None:
+        """
+        Align the dropdown to the position of the cursor within the target widget, and constrain it to be within the
+        screen.
+        """
+
+        x, y = self.target.cursor_screen_offset
+        dropdown = self.option_list
+        width, height = dropdown.outer_size
+
+        # Constrain the dropdown within the screen.
+        x, y, _width, _height = Region(x - 1, y + 1, width, height).constrain(
+            'inside',
+            'none',
+            Spacing.all(0),
+            self.screen.scrollable_content_region,
+        )
+        self.absolute_offset = Offset(x, y)
+
+    def _get_target_state(self) -> TargetState:
+        """Get the state of the target widget."""
+
+        target = self.target
+        return AutoComplete.TargetState(
+            text=target.value,
+            cursor_position=target.cursor_position,
+        )
+
+    def _handle_focus_change(self, has_focus: bool) -> None:
+        """Called when the focus of the target widget changes."""
+
+        if not has_focus:
+            self.action_hide()
+        else:
+            target_state = self._get_target_state()
+            search_string = self.get_search_string(target_state)
+            self._rebuild_options(target_state, search_string)
+
+    def _handle_target_update(self) -> None:
+        """
+        Called when the state (text or cursor position) of the target is updated.
+
+        Here we align the dropdown to the target, determine if it should be visible, and rebuild the options in it.
+        """
+
+        self._target_state = self._get_target_state()
+        search_string = self.get_search_string(self._target_state)
+
+        # Determine visibility after the user makes a change in the target widget (e.g. typing in a character in the
+        # Input).
+        self._rebuild_options(self._target_state, search_string)
+        self._align_to_target()
+
+        if self.should_show_dropdown(search_string):
+            self.action_show()
+        else:
+            self.action_hide()
+
+    def should_show_dropdown(self, search_string: str) -> bool:
+        """
+        Determine whether to show or hide the dropdown based on the current state.
+
+        This method can be overridden to customize the visibility behavior.
+
+        Args:
+            search_string: The current search string.
+
+        Returns:
+            bool: True if the dropdown should be shown, False otherwise.
+        """
+
+        option_list = self.option_list
+        option_count = option_list.option_count
+
+        if len(search_string) == 0 or option_count == 0:
+            return False
+        elif option_count == 1:
+            first_option = option_list.get_option_at_index(0).prompt
+            text_from_option = (
+                first_option.plain if isinstance(first_option, Text) else first_option
+            )
+            return text_from_option != search_string
+        else:
+            return True
+
+    def _rebuild_options(self, target_state: TargetState, search_string: str) -> None:
+        """
+        Rebuild the options in the dropdown.
+
+        Args:
+            target_state: The state of the target widget.
+        """
+
+        option_list = self.option_list
+        option_list.clear_options()
+        if self.target.has_focus:
+            matches = self._compute_matches(target_state, search_string)
+            if matches:
+                option_list.add_options(matches)
+                option_list.highlighted = 0
+
+    def get_search_string(self, target_state: TargetState) -> str:
+        """
+        This value will be passed to the match function.
+
+        This could be, for example, the text in the target widget, or a substring of that text.
+
+        Returns:
+            The search string that will be used to filter the dropdown options.
+        """
+
+        return target_state.text[: target_state.cursor_position]
+
+    def _compute_matches(self, target_state: TargetState, search_string: str) -> list[AutoCompleteItem]:
+        """
+        Compute the matches based on the target state.
+
+        Args:
+            target_state: The state of the target widget.
+
+        Returns:
+            The matches to display in the dropdown.
+        """
+
+        # If items is a callable, then it's a factory function that returns the candidates. Otherwise, it's a list of
+        # candidates.
+        candidates = self.get_candidates(target_state)
+        matches = self.get_matches(target_state, candidates, search_string)
+        return matches
+
+    def get_candidates(self, target_state: TargetState) -> list[AutoCompleteItem]:
+        """Get the candidates to match against."""
+
+        candidates = self.candidates
+        if isinstance(candidates, ta.Sequence):
+            return list(candidates)
+        elif candidates is None:
+            raise NotImplementedError(
+                'You must implement get_candidates in your AutoComplete subclass, because candidates is None',
+            )
+        else:
+            # candidates is a callable
+            return candidates(target_state)
+
+    def get_matches(
+            self,
+            target_state: TargetState,
+            candidates: list[AutoCompleteItem],
+            search_string: str,
+    ) -> list[AutoCompleteItem]:
+        """
+        Given the state of the target widget, return the DropdownItems which match the query string and should be appear
+        in the dropdown.
+
+        Args:
+            target_state: The state of the target widget.
+            candidates: The candidates to match against.
+            search_string: The search string to match against.
+
+        Returns:
+            The matches to display in the dropdown.
+        """
+
+        if not search_string:
+            return candidates
+
+        matches_and_scores: list[tuple[AutoCompleteItem, float]] = []
+        append_score = matches_and_scores.append
+        match = self.match
+
+        for candidate in candidates:
+            candidate_string = candidate.value
+            score, offsets = match(search_string, candidate_string)
+            if score > 0:
+                highlighted = self.apply_highlights(candidate.main, offsets)
+                highlighted_item = AutoCompleteItemHit(
+                    main=highlighted,
+                    prefix=candidate.prefix,
+                    id=candidate.id,
+                    disabled=candidate.disabled,
+                )
+                append_score((highlighted_item, score))
+
+        matches_and_scores.sort(key=operator.itemgetter(1), reverse=True)
+        matches = [match for match, _ in matches_and_scores]
+        return matches
+
+    def match(self, query: str, candidate: str) -> tuple[float, ta.Sequence[int]]:
+        """
+        Match a query (search string) against a candidate (dropdown item value).
+
+        Returns a tuple of (score, offsets) where score is a float between 0 and 1, used for sorting the matches, and
+        offsets is a tuple of integers representing the indices of the characters in the candidate string that match the
+        query.
+
+        So, if the query is "hello" and the candidate is "hello world", and the offsets will be (0,1,2,3,4). The score
+        can be anything you want - and the highest score will be at the top of the list by default.
+
+        The offsets will be highlighted in the dropdown list.
+
+        A score of 0 means no match, and such candidates will not be shown in the dropdown.
+
+        Args:
+            query: The search string.
+            candidate: The candidate string (dropdown item value).
+
+        Returns:
+            A tuple of (score, offsets).
+        """
+
+        return self._matcher(query, candidate)
+
+    def apply_highlights(self, candidate: Content, offsets: ta.Sequence[int]) -> Content:
+        """
+        Highlight the candidate with the fuzzy match offsets.
+
+        Args:
+            candidate: The candidate which matched the query. Note that this may already have its own styling applied.
+            offsets: The offsets to highlight.
+        Returns:
+            A [rich.text.Text][`Text`] object with highlighted matches.
+        """
+
+        # TODO - let's have styles which account for the cursor too
+        match_style = Style.from_rich_style(
+            self.get_component_rich_style('autocomplete--highlight-match', partial=True),
+        )
+
+        plain = candidate.plain
+        for offset in offsets:
+            if not plain[offset].isspace():
+                candidate = candidate.stylize(match_style, offset, offset + 1)
+
+        return candidate
+
+    @property
+    def option_list(self) -> AutoCompleteList:
+        return self.query_one(AutoCompleteList)
+
+    @on(OptionList.OptionSelected, 'AutoCompleteList')
+    def _apply_completion(self, event: OptionList.OptionSelected) -> None:
+        # Handles click events on dropdown items.
+        self._complete(event.option_index)

{omdev-0.0.0.dev463.dist-info → omdev-0.0.0.dev464.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omdev
-Version: 0.0.0.dev463
+Version: 0.0.0.dev464
 Summary: omdev
 Author: wrmsr
 License-Expression: BSD-3-Clause
@@ -14,7 +14,7 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: omlish==0.0.0.dev463
+Requires-Dist: omlish==0.0.0.dev464
 Provides-Extra: all
 Requires-Dist: black~=25.9; extra == "all"
 Requires-Dist: pycparser~=2.23; extra == "all"

{omdev-0.0.0.dev463.dist-info → omdev-0.0.0.dev464.dist-info}/RECORD

@@ -344,15 +344,20 @@ omdev/tui/apps/irc/main.py,sha256=ptsSjKE3LDmPERCExivcjTN7SOfYY7WVnIlDXSL_XQA,51
 omdev/tui/apps/markdown/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omdev/tui/apps/markdown/__main__.py,sha256=Xy-G2-8Ymx8QMBbRzA4LoiAMZqvtC944mMjFEWd69CA,182
 omdev/tui/apps/markdown/cli.py,sha256=K1vH7f3ZqLv4xTPluhJBEZH8nx8n42_vXIALEV07Q50,469
-omdev/tui/rich/__init__.py,sha256=_PcNDlzl7FIa071qni4AlBAf0oXXFHUjEaPxumnuXWs,775
+omdev/tui/rich/__init__.py,sha256=ZmStqeMrES5FiHLCysKRcg3vvmrIfksIZknDIGD1o0E,809
 omdev/tui/rich/console2.py,sha256=BYYLbbD65If9TvfPI6qUcMQKUWJbuWwykEzPplvkf6A,342
 omdev/tui/rich/markdown2.py,sha256=fBcjG_34XzUf4WclBL_MxvBj5NUwvLCANhHCx3R0akw,6139
-omdev/tui/textual/__init__.py,sha256=l4lDY7g_spyUpCMYlzmM2jFz92xv4-VzOM88vFlV6zA,9801
+omdev/tui/textual/__init__.py,sha256=2InVQxcIgL5-JcfsQWp_FoQcTLm6TJdZAd-WSwuoIYo,10621
 omdev/tui/textual/app2.py,sha256=QNh8dX9lXtvWkUOLX5x6ucJCYqDoKD78VDpaX4ZcGS8,225
 omdev/tui/textual/drivers2.py,sha256=ZVxI9n6cyczjrdjqKOAjE51pF0yppACJOVmqLaWuJuM,1402
-omdev-0.0.0.dev463.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omdev-0.0.0.dev463.dist-info/METADATA,sha256=BZD4CAxJpONI1QQgQF1aYu6dr7WvhH_OXomlZy-_guA,5170
-omdev-0.0.0.dev463.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-omdev-0.0.0.dev463.dist-info/entry_points.txt,sha256=dHLXFmq5D9B8qUyhRtFqTGWGxlbx3t5ejedjrnXNYLU,33
-omdev-0.0.0.dev463.dist-info/top_level.txt,sha256=1nr7j30fEWgLYHW3lGR9pkdHkb7knv1U1ES1XRNVQ6k,6
-omdev-0.0.0.dev463.dist-info/RECORD,,
+omdev/tui/textual/autocomplete/LICENSE,sha256=E4XIgwSRB-UmqQi5b3HvRUfmpR9vfi99rvxGjnkS6BI,1069
+omdev/tui/textual/autocomplete/__init__.py,sha256=m0EGewct7SoATrTcsCSmeRQyPucP5Sqew5qZOIQUgKI,1442
+omdev/tui/textual/autocomplete/matching.py,sha256=joxUxF4jfs47E4JK0DAo_l0lwoNe9mU6iJzxI2FlVYI,6801
+omdev/tui/textual/autocomplete/paths.py,sha256=Z3ZlTkPZezKBaFgB23d6IFJXanJc8OueBm-S0kExdRM,7242
+omdev/tui/textual/autocomplete/widget.py,sha256=1UgWqDT0d9wD6w7MNaZBjgj0o9FohYXydifocPErdks,22629
+omdev-0.0.0.dev464.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omdev-0.0.0.dev464.dist-info/METADATA,sha256=vlahtbj1bv8e_wIrAp2kUn7cfKwzLIhqroKpLgeryfo,5170
+omdev-0.0.0.dev464.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+omdev-0.0.0.dev464.dist-info/entry_points.txt,sha256=dHLXFmq5D9B8qUyhRtFqTGWGxlbx3t5ejedjrnXNYLU,33
+omdev-0.0.0.dev464.dist-info/top_level.txt,sha256=1nr7j30fEWgLYHW3lGR9pkdHkb7knv1U1ES1XRNVQ6k,6
+omdev-0.0.0.dev464.dist-info/RECORD,,