urwid 2.6.0.post0__py3-none-any.whl

urwid/widget/__init__.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+from .attr_map import AttrMap, AttrMapError
+from .attr_wrap import AttrWrap
+from .bar_graph import BarGraph, BarGraphError, BarGraphMeta, GraphVScale, scale_bar_values
+from .big_text import BigText
+from .box_adapter import BoxAdapter, BoxAdapterError
+from .columns import Columns, ColumnsError, ColumnsWarning
+from .constants import (
+    RELATIVE_100,
+    Align,
+    Sizing,
+    VAlign,
+    WHSettings,
+    WrapMode,
+    normalize_align,
+    normalize_height,
+    normalize_valign,
+    normalize_width,
+    simplify_align,
+    simplify_height,
+    simplify_valign,
+    simplify_width,
+)
+from .container import WidgetContainerListContentsMixin, WidgetContainerMixin
+from .divider import Divider
+from .edit import Edit, EditError, IntEdit
+from .filler import Filler, FillerError, calculate_top_bottom_filler
+from .frame import Frame, FrameError
+from .grid_flow import GridFlow, GridFlowError
+from .line_box import LineBox
+from .overlay import Overlay, OverlayError, OverlayWarning
+from .padding import Padding, PaddingError, PaddingWarning, calculate_left_right_padding
+from .pile import Pile, PileError, PileWarning
+from .popup import PopUpLauncher, PopUpTarget
+from .progress_bar import ProgressBar
+from .scrollable import Scrollable, ScrollableError, ScrollBar
+from .solid_fill import SolidFill
+from .text import Text, TextError
+from .widget import (
+    BoxWidget,
+    FixedWidget,
+    FlowWidget,
+    Widget,
+    WidgetError,
+    WidgetMeta,
+    WidgetWarning,
+    WidgetWrap,
+    WidgetWrapError,
+    delegate_to_widget_mixin,
+    fixed_size,
+    nocache_widget_render,
+    nocache_widget_render_instance,
+)
+from .widget_decoration import WidgetDecoration, WidgetDisable, WidgetPlaceholder
+from .wimp import Button, CheckBox, CheckBoxError, RadioButton, SelectableIcon
+
+__all__ = (
+    "ANY",
+    "BOTTOM",
+    "BOX",
+    "CENTER",
+    "CLIP",
+    "ELLIPSIS",
+    "FIXED",
+    "FLOW",
+    "GIVEN",
+    "LEFT",
+    "MIDDLE",
+    "PACK",
+    "RELATIVE",
+    "RELATIVE_100",
+    "RIGHT",
+    "SPACE",
+    "TOP",
+    "WEIGHT",
+    "Align",
+    "AttrMap",
+    "AttrMapError",
+    "AttrWrap",
+    "BarGraph",
+    "BarGraphError",
+    "BarGraphMeta",
+    "BigText",
+    "BoxAdapter",
+    "BoxAdapterError",
+    "BoxWidget",
+    "Button",
+    "CheckBox",
+    "CheckBoxError",
+    "Columns",
+    "ColumnsError",
+    "ColumnsWarning",
+    "Divider",
+    "Edit",
+    "EditError",
+    "Filler",
+    "FillerError",
+    "FixedWidget",
+    "FlowWidget",
+    "Frame",
+    "FrameError",
+    "GraphVScale",
+    "GridFlow",
+    "GridFlowError",
+    "IntEdit",
+    "LineBox",
+    "Overlay",
+    "OverlayError",
+    "OverlayWarning",
+    "Padding",
+    "PaddingError",
+    "PaddingWarning",
+    "Pile",
+    "PileError",
+    "PileWarning",
+    "PopUpLauncher",
+    "PopUpTarget",
+    "ProgressBar",
+    "RadioButton",
+    "ScrollBar",
+    "Scrollable",
+    "ScrollableError",
+    "SelectableIcon",
+    "Sizing",
+    "SolidFill",
+    "Text",
+    "TextError",
+    "VAlign",
+    "WHSettings",
+    "Widget",
+    "WidgetContainerListContentsMixin",
+    "WidgetContainerMixin",
+    "WidgetDecoration",
+    "WidgetDisable",
+    "WidgetError",
+    "WidgetMeta",
+    "WidgetPlaceholder",
+    "WidgetWarning",
+    "WidgetWrap",
+    "WidgetWrapError",
+    "WrapMode",
+    "calculate_left_right_padding",
+    "calculate_top_bottom_filler",
+    "delegate_to_widget_mixin",
+    "fixed_size",
+    "nocache_widget_render",
+    "nocache_widget_render_instance",
+    "normalize_align",
+    "normalize_height",
+    "normalize_valign",
+    "normalize_width",
+    "scale_bar_values",
+    "simplify_align",
+    "simplify_height",
+    "simplify_valign",
+    "simplify_width",
+)
+
+# Backward compatibility
+FLOW = Sizing.FLOW
+BOX = Sizing.BOX
+FIXED = Sizing.FIXED
+
+LEFT = Align.LEFT
+RIGHT = Align.RIGHT
+CENTER = Align.CENTER
+
+TOP = VAlign.TOP
+MIDDLE = VAlign.MIDDLE
+BOTTOM = VAlign.BOTTOM
+
+SPACE = WrapMode.SPACE
+ANY = WrapMode.ANY
+CLIP = WrapMode.CLIP
+ELLIPSIS = WrapMode.ELLIPSIS
+
+PACK = WHSettings.PACK
+GIVEN = WHSettings.GIVEN
+RELATIVE = WHSettings.RELATIVE
+WEIGHT = WHSettings.WEIGHT

urwid/widget/attr_map.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+import typing
+from collections.abc import Hashable, Mapping
+
+from urwid.canvas import CompositeCanvas
+
+from .widget import WidgetError, delegate_to_widget_mixin
+from .widget_decoration import WidgetDecoration
+
+WrappedWidget = typing.TypeVar("WrappedWidget")
+
+
+class AttrMapError(WidgetError):
+    pass
+
+
+class AttrMap(delegate_to_widget_mixin("_original_widget"), WidgetDecoration[WrappedWidget]):
+    """
+    AttrMap is a decoration that maps one set of attributes to another.
+    This object will pass all function calls and variable references to the
+    wrapped widget.
+    """
+
+    def __init__(
+        self,
+        w: WrappedWidget,
+        attr_map: Hashable | Mapping[Hashable | None, Hashable] | None,
+        focus_map: Hashable | Mapping[Hashable | None, Hashable] | None = None,
+    ) -> None:
+        """
+        :param w: widget to wrap (stored as self.original_widget)
+        :type w: widget
+
+        :param attr_map: attribute to apply to *w*, or dict of old display
+            attribute: new display attribute mappings
+        :type attr_map: display attribute or dict
+
+        :param focus_map: attribute to apply when in focus or dict of
+            old display attribute: new display attribute mappings;
+            if ``None`` use *attr*
+        :type focus_map: display attribute or dict
+
+        >>> from urwid import Divider, Edit, Text
+        >>> AttrMap(Divider(u"!"), 'bright')
+        <AttrMap flow widget <Divider flow widget '!'> attr_map={None: 'bright'}>
+        >>> AttrMap(Edit(), 'notfocus', 'focus').attr_map
+        {None: 'notfocus'}
+        >>> AttrMap(Edit(), 'notfocus', 'focus').focus_map
+        {None: 'focus'}
+        >>> size = (5,)
+        >>> am = AttrMap(Text(u"hi"), 'greeting', 'fgreet')
+        >>> next(am.render(size, focus=False).content()) # ... = b in Python 3
+        [('greeting', None, ...'hi   ')]
+        >>> next(am.render(size, focus=True).content())
+        [('fgreet', None, ...'hi   ')]
+        >>> am2 = AttrMap(Text(('word', u"hi")), {'word':'greeting', None:'bg'})
+        >>> am2
+        <AttrMap fixed/flow widget <Text fixed/flow widget 'hi'> attr_map={'word': 'greeting', None: 'bg'}>
+        >>> next(am2.render(size).content())
+        [('greeting', None, ...'hi'), ('bg', None, ...'   ')]
+        """
+        super().__init__(w)
+
+        if isinstance(attr_map, Mapping):
+            self.attr_map = dict(attr_map)
+        else:
+            self.attr_map = {None: attr_map}
+
+        if isinstance(focus_map, Mapping):
+            self.focus_map = dict(focus_map)
+        elif focus_map is None:
+            self.focus_map = focus_map
+        else:
+            self.focus_map = {None: focus_map}
+
+    def _repr_attrs(self) -> dict[str, typing.Any]:
+        # only include the focus_attr when it takes effect (not None)
+        d = {**super()._repr_attrs(), "attr_map": self._attr_map}
+        if self._focus_map is not None:
+            d["focus_map"] = self._focus_map
+        return d
+
+    def get_attr_map(self) -> dict[Hashable | None, Hashable]:
+        # make a copy so ours is not accidentally modified
+        # FIXME: a dictionary that detects modifications would be better
+        return dict(self._attr_map)
+
+    def set_attr_map(self, attr_map: dict[Hashable | None, Hashable] | None) -> None:
+        """
+        Set the attribute mapping dictionary {from_attr: to_attr, ...}
+
+        Note this function does not accept a single attribute the way the
+        constructor does.  You must specify {None: attribute} instead.
+
+        >>> from urwid import Text
+        >>> w = AttrMap(Text(u"hi"), None)
+        >>> w.set_attr_map({'a':'b'})
+        >>> w
+        <AttrMap fixed/flow widget <Text fixed/flow widget 'hi'> attr_map={'a': 'b'}>
+        """
+        for from_attr, to_attr in attr_map.items():
+            if not isinstance(from_attr, Hashable) or not isinstance(to_attr, Hashable):
+                raise AttrMapError(
+                    f"{from_attr!r}:{to_attr!r} attribute mapping is invalid. Attributes must be hashable"
+                )
+
+        self._attr_map = attr_map
+        self._invalidate()
+
+    attr_map = property(get_attr_map, set_attr_map)
+
+    def get_focus_map(self) -> dict[Hashable | None, Hashable] | None:
+        # make a copy so ours is not accidentally modified
+        # FIXME: a dictionary that detects modifications would be better
+        if self._focus_map:
+            return dict(self._focus_map)
+        return None
+
+    def set_focus_map(self, focus_map: dict[Hashable | None, Hashable] | None) -> None:
+        """
+        Set the focus attribute mapping dictionary
+        {from_attr: to_attr, ...}
+
+        If None this widget will use the attr mapping instead (no change
+        when in focus).
+
+        Note this function does not accept a single attribute the way the
+        constructor does.  You must specify {None: attribute} instead.
+
+        >>> from urwid import Text
+        >>> w = AttrMap(Text(u"hi"), {})
+        >>> w.set_focus_map({'a':'b'})
+        >>> w
+        <AttrMap fixed/flow widget <Text fixed/flow widget 'hi'> attr_map={} focus_map={'a': 'b'}>
+        >>> w.set_focus_map(None)
+        >>> w
+        <AttrMap fixed/flow widget <Text fixed/flow widget 'hi'> attr_map={}>
+        """
+        if focus_map is not None:
+            for from_attr, to_attr in focus_map.items():
+                if not isinstance(from_attr, Hashable) or not isinstance(to_attr, Hashable):
+                    raise AttrMapError(
+                        f"{from_attr!r}:{to_attr!r} attribute mapping is invalid. Attributes must be hashable"
+                    )
+        self._focus_map = focus_map
+        self._invalidate()
+
+    focus_map = property(get_focus_map, set_focus_map)
+
+    def render(self, size, focus: bool = False) -> CompositeCanvas:
+        """
+        Render wrapped widget and apply attribute. Return canvas.
+        """
+        attr_map = self._attr_map
+        if focus and self._focus_map is not None:
+            attr_map = self._focus_map
+        canv = self._original_widget.render(size, focus=focus)
+        canv = CompositeCanvas(canv)
+        canv.fill_attr_apply(attr_map)
+        return canv

urwid/widget/attr_wrap.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+import typing
+import warnings
+
+from .attr_map import AttrMap
+
+if typing.TYPE_CHECKING:
+    from .constants import Sizing
+    from .widget import Widget
+
+
+class AttrWrap(AttrMap):
+    def __init__(self, w: Widget, attr, focus_attr=None):
+        """
+        w -- widget to wrap (stored as self.original_widget)
+        attr -- attribute to apply to w
+        focus_attr -- attribute to apply when in focus, if None use attr
+
+        This widget is a special case of the new AttrMap widget, and it
+        will pass all function calls and variable references to the wrapped
+        widget.  This class is maintained for backwards compatibility only,
+        new code should use AttrMap instead.
+
+        >>> from urwid import Divider, Edit, Text
+        >>> AttrWrap(Divider(u"!"), 'bright')
+        <AttrWrap flow widget <Divider flow widget '!'> attr='bright'>
+        >>> AttrWrap(Edit(), 'notfocus', 'focus')
+        <AttrWrap selectable flow widget <Edit selectable flow widget '' edit_pos=0> attr='notfocus' focus_attr='focus'>
+        >>> size = (5,)
+        >>> aw = AttrWrap(Text(u"hi"), 'greeting', 'fgreet')
+        >>> next(aw.render(size, focus=False).content())
+        [('greeting', None, ...'hi   ')]
+        >>> next(aw.render(size, focus=True).content())
+        [('fgreet', None, ...'hi   ')]
+        """
+        warnings.warn(
+            "AttrWrap is maintained for backwards compatibility only, new code should use AttrMap instead.",
+            PendingDeprecationWarning,
+            stacklevel=2,
+        )
+        super().__init__(w, attr, focus_attr)
+
+    def _repr_attrs(self) -> dict[str, typing.Any]:
+        # only include the focus_attr when it takes effect (not None)
+        d = {**super()._repr_attrs(), "attr": self.attr}
+        del d["attr_map"]
+        if "focus_map" in d:
+            del d["focus_map"]
+        if self.focus_attr is not None:
+            d["focus_attr"] = self.focus_attr
+        return d
+
+    @property
+    def w(self) -> Widget:
+        """backwards compatibility, widget used to be stored as w"""
+        warnings.warn(
+            "backwards compatibility, widget used to be stored as original_widget",
+            PendingDeprecationWarning,
+            stacklevel=2,
+        )
+        return self.original_widget
+
+    @w.setter
+    def w(self, new_widget: Widget) -> None:
+        warnings.warn(
+            "backwards compatibility, widget used to be stored as original_widget",
+            PendingDeprecationWarning,
+            stacklevel=2,
+        )
+        self.original_widget = new_widget
+
+    def get_w(self):
+        warnings.warn(
+            "backwards compatibility, widget used to be stored as original_widget",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.original_widget
+
+    def set_w(self, new_widget: Widget) -> None:
+        warnings.warn(
+            "backwards compatibility, widget used to be stored as original_widget",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        self.original_widget = new_widget
+
+    def get_attr(self):
+        return self.attr_map[None]
+
+    def set_attr(self, attr):
+        """
+        Set the attribute to apply to the wrapped widget
+
+        >> w = AttrWrap(Divider("-"), None)
+        >> w.set_attr('new_attr')
+        >> w
+        <AttrWrap flow widget <Divider flow widget '-'> attr='new_attr'>
+        """
+        self.set_attr_map({None: attr})
+
+    attr = property(get_attr, set_attr)
+
+    def get_focus_attr(self):
+        focus_map = self.focus_map
+        if focus_map:
+            return focus_map[None]
+        return None
+
+    def set_focus_attr(self, focus_attr):
+        """
+        Set the attribute to apply to the wapped widget when it is in
+        focus
+
+        If None this widget will use the attr instead (no change when in
+        focus).
+
+        >> w = AttrWrap(Divider("-"), 'old')
+        >> w.set_focus_attr('new_attr')
+        >> w
+        <AttrWrap flow widget <Divider flow widget '-'> attr='old' focus_attr='new_attr'>
+        >> w.set_focus_attr(None)
+        >> w
+        <AttrWrap flow widget <Divider flow widget '-'> attr='old'>
+        """
+        self.set_focus_map({None: focus_attr})
+
+    focus_attr = property(get_focus_attr, set_focus_attr)
+
+    def __getattr__(self, name: str):
+        """
+        Call getattr on wrapped widget.  This has been the longstanding
+        behaviour of AttrWrap, but is discouraged.  New code should be
+        using AttrMap and .base_widget or .original_widget instead.
+        """
+        return getattr(self._original_widget, name)
+
+    def sizing(self) -> frozenset[Sizing]:
+        return self._original_widget.sizing()