@scemoon/cdh 1.0.5 → 1.0.7

package/tui/_path_match.py

@@ -1,141 +0,0 @@
-from functools import lru_cache
-from operator import itemgetter
-import re
-from typing import Iterable, Sequence
-
-
-class PathFuzzySearch:
-    """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
-
-    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.
-        """
-        default: tuple[float, Sequence[int]] = (0.0, [])
-        result = max(self._match(query, candidate), key=itemgetter(0), default=default)
-        return result
-
-    @classmethod
-    @lru_cache(maxsize=1024)
-    def get_first_letters(cls, candidate: str) -> frozenset[int]:
-        return frozenset(
-            {
-                0,
-                *[match.start() + 1 for match in re.finditer(r"/", 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)
-
-        if positions[0] > candidate.rfind("/"):
-            score *= 2
-        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
-
-
-_fuzzy_search = PathFuzzySearch(case_sensitive=False)
-
-
-def match_path(query_path: tuple[str, str]) -> tuple[float, Sequence[int], str]:
-    global _fuzzy_search
-    query, path = query_path
-    score, indices = _fuzzy_search.match(query, path)
-    return (
-        score,
-        tuple(indices),
-        path,
-    )

package/tui/about.py

@@ -1,95 +0,0 @@
-import os
-from importlib.metadata import version
-import platform
-from string import Template
-
-from tui.app import A2TUIApp
-from tui import paths
-from tui import get_version
-
-ABOUT_TEMPLATE = Template(
-    """\
-# About A2TUI v${TOAD_VERSION}
-
-© Will McGugan.
-                          
-A2TUI is licensed under the terms of the [GNU AFFERO GENERAL PUBLIC LICENSE](https://www.gnu.org/licenses/agpl-3.0.txt).
-
-
-## Config
-
-config read from `$SETTINGS_PATH`
-                                       
-```json
-$CONFIG                       
-```
-
-## Paths
-
-| Name | Path |
-| --- | --- |
-| App data | `$DATA_PATH` |
-| App state | `$STATE_PATH` |
-| App logs | `$LOG_PATH` |
-
-                          
-## System
-
-| System | Version |
-| --- | --- |
-| Python | $PYTHON |
-| OS | $PLATFORM |
-| Terminal | $TERMINAL |
-
-## Dependencies
-
-| Library | Version |
-| --- | --- | 
-| A2TUI | $TOAD_VERSION |
-| Textual | $TEXTUAL_VERSION |
-| Rich | $RICH_VERSION |
-                          
-## Environment
-
-| Environment variable | Value |                
-| --- | --- |
-| `SHELL` | $SHELL |
-| `TERM` | $TERM |
-| `COLORTERM` | $COLORTERM |
-| `TERM_PROGRAM` | $TERM_PROGRAM |
-| `TERM_PROGRAM_VERSION` | $TERM_PROGRAM_VERSION |
-"""
-)
-
-
-def render(app: A2TUIApp) -> str:
-    """Render about markdown.
-
-    Returns:
-        Markdown string.
-    """
-
-    try:
-        config: str | None = app.settings_path.read_text()
-    except Exception:
-        config = None
-
-    template_data = {
-        "COLORTERM": os.environ.get("COLORTERM", ""),
-        "CONFIG": config,
-        "DATA_PATH": paths.get_data(),
-        "LOG_PATH": paths.get_log(),
-        "STATE_PATH": paths.get_state(),
-        "PLATFORM": platform.platform(),
-        "PYTHON": f"{platform.python_implementation()} {platform.python_version()}",
-        "RICH_VERSION": version("rich"),
-        "SETTINGS_PATH": str(app.settings_path),
-        "SHELL": os.environ.get("SHELL", ""),
-        "TERM_PROGRAM_VERSION": os.environ.get("TERM_PROGRAM_VERSION", ""),
-        "TERM_PROGRAM": os.environ.get("TERM_PROGRAM", ""),
-        "TERM": os.environ.get("TERM", ""),
-        "TEXTUAL_VERSION": version("textual"),
-        "TOAD_VERSION": get_version(),
-        "TERMINAL": app.term_program,
-    }
-    return ABOUT_TEMPLATE.safe_substitute(template_data)