Skip to content

base

Extension Classes

SortedBindingsApp #

Bases: App[str]

Textual App with Sorted Bindings

Source code in browsr/base.py 
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
class SortedBindingsApp(App[str]):
    """
    Textual App with Sorted Bindings
    """

    BINDING_WEIGHTS: ClassVar[dict[str, int]] = {}

    @property
    def namespace_bindings(self) -> dict[str, tuple[DOMNode, Binding]]:
        """
        Return the namespace bindings, optionally sorted by weight

        Bindings are currently returned as they're rendered in the
        current namespace (screen). This method can be overridden to
        return bindings in a specific order.

        Rules:
        - Binding weights must be greater than 0 and less than 10000
        - If a binding is not in the BINDING_WEIGHTS dict, it will be
          given a weight of 500 + its current position in the namespace.
        - Specified weights cannot overlap with the default weights (stay
          away from the 500 range)

        Raises
        ------
        ValueError
            If binding weights are invalid

        Returns
        -------
        dict[str, tuple[DOMNode, Binding]]
            A dictionary of bindings
        """
        existing_bindings = super().namespace_bindings
        if not self.BINDING_WEIGHTS:
            return existing_bindings
        builtin_index = 500
        max_weight = 999
        binding_range = range(builtin_index, builtin_index + len(existing_bindings))
        weights = dict(zip(existing_bindings.keys(), binding_range))
        if max(*self.BINDING_WEIGHTS.values(), 0) > max_weight:
            raise ValueError("Binding weights must be less than 1000")
        elif min(*self.BINDING_WEIGHTS.values(), 1) < 1:
            raise ValueError("Binding weights must be greater than 0")
        elif set(self.BINDING_WEIGHTS.values()).intersection(binding_range):
            raise ValueError("Binding weights must not overlap with existing bindings")
        weights.update(self.BINDING_WEIGHTS)
        updated_bindings = dict(
            sorted(
                existing_bindings.items(),
                key=lambda item: weights[item[0]],
            ),
        )
        return updated_bindings

namespace_bindings: dict[str, tuple[DOMNode, Binding]] property #

Return the namespace bindings, optionally sorted by weight

Bindings are currently returned as they're rendered in the current namespace (screen). This method can be overridden to return bindings in a specific order.

Rules: - Binding weights must be greater than 0 and less than 10000 - If a binding is not in the BINDING_WEIGHTS dict, it will be given a weight of 500 + its current position in the namespace. - Specified weights cannot overlap with the default weights (stay away from the 500 range)

Raises:

Type Description
ValueError

If binding weights are invalid

Returns:

Type Description
dict[str, tuple[DOMNode, Binding]]

A dictionary of bindings

TextualAppContext dataclass #

App Context Object

Source code in browsr/base.py 
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
@dataclass
class TextualAppContext:
    """
    App Context Object
    """

    file_path: str = field(default_factory=os.getcwd)
    config: dict[str, Any] | None = None
    debug: bool = False
    max_file_size: int = 20
    max_lines: int = 1000
    kwargs: dict[str, Any] | None = None

    @property
    def path(self) -> UPath:
        """
        Resolve `file_path` to a UPath object
        """
        if "github" in str(self.file_path).lower():
            file_path = str(self.file_path)
            file_path = file_path.lstrip("https://")  # noqa: B005
            file_path = file_path.lstrip("http://")  # noqa: B005
            file_path = file_path.lstrip("www.")  # noqa: B005
            if file_path.endswith(".git"):
                file_path = file_path[:-4]
            file_path = handle_github_url(url=str(file_path))
            self.file_path = file_path
        if str(self.file_path).endswith("/") and len(str(self.file_path)) > 1:
            self.file_path = str(self.file_path)[:-1]
        storage_options = self.kwargs or {}
        if not self.file_path:
            return pathlib.Path.cwd().resolve()
        else:
            path = UPath(self.file_path, **storage_options)
            return path.resolve()

path: UPath property #

Resolve file_path to a UPath object