jjFgddlmZddlZddlZddlZddlZddlmZddlm Z ddl m Z m Z m Z ddlmZddlmZddlmZd d lmZej,rdd lmZmZej4d Zej8eZGd de j>eZ Gdde!Z"Gdde#Z$dZ%dZ&dZ'dZ(dZ)Gdde Z*d$dZ+d%dZ,Gdde!Z-Gdd e,d!ej\eZ/d"Z0ed#k(re0yy)&) annotationsN) attrgetter)signals)Canvas CanvasCacheCompositeCanvas) command_map split_repr) MetaSuper)Sizing)CallableHashable WrappedWidgetc"eZdZdZfdZxZS) WidgetMetaa Bases: :class:`MetaSuper`, :class:`MetaSignals` Automatic caching of render and rows methods. Class variable *no_cache* is a list of names of methods to not cache automatically. Valid method names for *no_cache* are ``'render'`` and ``'rows'``. Class variable *ignore_focus* if defined and set to ``True`` indicates that the canvas this widget renders is not affected by the focus parameter, so it may be ignored when caching. c|jdg}t| |||d|vr"d|vr t|}n t |}||_d|vrd|vrt ||_d|vr|`d|vr|` yy)Nno_cacherenderrows ignore_focus) getsuper__init__cache_widget_rendernocache_widget_renderrcache_widget_rowsrrr)clsnamebasesdr render_fn __class__s \/home/ubuntu/.cache/pipx/cdb5059130eadca/lib/python3.12/site-packages/urwid/widget/widget.pyrzWidgetMeta.__init__;s55R( ua( q=x'/4 1#6 "CJ Q;61(-CH ? Q   )__name__ __module__ __qualname____doc__r __classcell__r$s@r%rr,s !!r&rceZdZdZy) WidgetErrorzWidget specific errors.Nr'r(r)r*r&r%r.r.Os!r&r.ceZdZdZy) WidgetWarningzWidget specific warnings.Nr/r0r&r%r2r2Ss#r&r2c |r|dddk7r|d|jk7s$t|dkDrM|d|jk7r6td|d|jdd|jdd |d yy) z< Raise a WidgetError if a canv does not match size. r N)rrWidget z rendered (r"z x z) canvas when passed size !)colslenrr.)widgetsizecanvs r% validate_sizer;Ws abT!d1g&<#d)a-TXYZT[_c_h_h_jTjfZ{499;q/TYY[OKefjemmn o  Uk-r&cttddjtjdfd }|_|S)zt Return a function that wraps the cls.render() method and fetches and stores canvases with CanvasCache. rFc|xr }tj|||x}r|S|||}t||||jr t |}|j |||tj ||SN)focus)rfetchr; widget_inforfinalizestoreselfr9r?r:rfnrs r% cached_renderz*cache_widget_render..cached_renderis*l*$$T3e< <4 <K$E*dD$'   "4(D dD%(#t$ r&F)boolgetattrr functoolswraps original_fn)rrGrFrs` @@r%rrasL ^U;)rArr;rB)rEr9r?r:rFs r%finalize_renderz.nocache_widget_render..finalize_rendersE$E*   "4(DdD$' dD%( r&rH)rhasattrrMrKrL)rrPrFs @r%rr|sL Br=! ^^__R#%O r&cjjtjdfd }|_|S)z Return a function that wraps the cls.render() method and finalizes the canvas that it returns, but does not cache the canvas. cr||}|jr t|}|j|||Sr>)rArrB)r9r?r:rFrEs r%rPz7nocache_widget_render_instance..finalize_renders9$E*   "4(D dD%( r&rH)rrMrKrL)rErPrFs` @r%nocache_widget_render_instancerTs?  B__R#%O r&cttddjtjddfd }|S)zt Return a function that wraps the cls.rows() method and returns rows from the CanvasCache if available. rFcz|xr }tj|||x}r|jS|||SN)rr@rrDs r% cached_rowsz&cache_widget_rows..cached_rowssG*l*$$T3e< <4 <99; $e$$r&rH)r9z tuple[int]r?rIreturnint)rIrJrrKrL)rrXrFrs` @@r%rrsD ^U;>+D+D*EQt~~G^G^F_(`a r&c.tj|y)zZMark cached canvases rendered by this widget as dirty so that they will not be used again.N)r invalidaterbs r% _invalidatezWidget._invalidate0st$r&c4tj|||g|y)zAConvenience function to emit signals with self as first argument.N)r emit_signal)rEr argss r%_emitz Widget._emit4sD$4t4r&c|jS)ao :returns: ``True`` if this is a widget that is designed to take the focus, i.e. it contains something the user might want to interact with, ``False`` otherwise, This default implementation returns :attr:`._selectable`. Subclasses may leave these is if the are not selectable, or if they are always selectable they may set the :attr:`_selectable` class variable to ``True``. If this method returns ``True`` then the :meth:`.keypress` method must be implemented. Returning ``False`` does not guarantee that this widget will never be in focus, only that this widget will usually be skipped over when changing focus. It is still possible for non selectable widgets to have the focus (typically when there are no other selectable widgets visible). ) _selectablerbs r% selectablezWidget.selectable8s&r&c|jS)a3 :returns: A frozenset including one or more of ``'box'``, ``'flow'`` and ``'fixed'``. Default implementation returns the value of :attr:`._sizing`, which for this class includes all three. The sizing modes returned indicate the modes that may be supported by this widget, but is not sufficient to know that using that sizing mode will work. Subclasses should make an effort to remove sizing modes they know will not work given the state of the widget, but many do not yet do this. If a sizing mode is missing from the set then the widget should fail when used in that mode. If ``'flow'`` is among the values returned then the other methods in this widget must be able to accept a single-element tuple (*maxcol*,) to their ``size`` parameter, and the :meth:`rows` method must be defined. If ``'box'`` is among the values returned then the other methods must be able to accept a two-element tuple (*maxcol*, *maxrow*) to their size parameter. If ``'fixed'`` is among the values returned then the other methods must be able to accept an empty tuple () to their size parameter, and the :meth:`pack` method must be defined. )_sizingrbs r%sizingz Widget.sizingMs<||r&c(|s{{dkkm+66tyyu566 WX\W_`a a r&c|S)zRead-only property that steps through decoration widgets and returns the one at the base. This default implementation returns self. r0rbs r% base_widgetzWidget.base_widgets  r&cy)z Read-only property returning the child widget in focus for container widgets. This default implementation always returns ``None``, indicating that this widget has no children. Nr0rbs r%r?z Widget.focussr&Nc td|d)NzNo focus_position, z is not a container widget) IndexError)rEvals r%_not_a_containerzWidget._not_a_containers.th6PQRRr&a Property for reading and setting the focus position for container widgets. This default implementation raises :exc:`IndexError`, making normal widgets fail the same way accessing :attr:`.focus_position` on an empty container widget would. )docct|S)zA friendly __repr__ for widgets. Designed to be extended by subclasses with _repr_words and _repr_attr methods. r rbs r%__repr__zWidget.__repr__s $r&c\g}|jrdg|}|jr|jttjtj tj gk7r7|jdjt|jg|dS)Nrl/r8) rlro frozensetrrsBOXrqappendjoinsorted)rEwordss r% _repr_wordszWidget._repr_wordss ?? !*E*E ;;=T[[]ifjjRXR^R^8_.`` LL&"78 9!!!!r&ciSrWr0rbs r% _repr_attrszWidget._repr_attrss r&c|jsyt|dr |jjd||St j d|j jdtdtjd|d|S)a|Keyboard input handler. :param size: See :meth:`Widget.render` for details :type size: tuple[()] | tuple[int] | tuple[int, int] :param key: a single keystroke value; see :ref:`keyboard-input` :type key: str :return: ``None`` if *key* was handled by *key* (the same value passed) if *key* was not handled :rtype: str | None raz'keypress sent to non selectable widget r4z! did not call 'super().__init__() stacklevel is not selectable rlrQradebugwarningswarnr$r'r2LOGGER)rEr9keys r%keypresszWidget.keypresss tX& !!$KD8"TU  dnn5566WX!   wth.@AB r&c|jsyt|dr |jjd|dyt j d|j jdtdtjd|dy)aMouse event handler. :param size: See :meth:`Widget.render` for details. :type size: tuple[()] | tuple[int] | tuple[int, int] :param event: Values such as ``'mouse press'``, ``'ctrl mouse press'``, ``'mouse release'``, ``'meta mouse release'``, ``'mouse drag'``; see :ref:`mouse-input` :type event: str :param button: 1 through 5 for press events, often 0 for release events (which button was released is often not known) :type button: int :param col: Column of the event, 0 is the left edge of this widget :type col: int :param row: Row of the event, 0 it the top row of this widget :type row: int :param focus: Set to ``True`` if this widget or one of its children is in focus :type focus: bool :return: ``True`` if the event was handled by this widget, ``False`` otherwise :rtype: bool | None rar4rz not called 'super().__init__()rrFr)rEr9eventbuttoncolrowr?s r% mouse_eventzWidget.mouse_events: tX& !!GD83E"FG  dnn5566UV!   wth.@ABr&ct)aPRender widget and produce canvas :param size: One of the following, *maxcol* and *maxrow* are integers > 0: (*maxcol*, *maxrow*) for box sizing -- the parent chooses the exact size of this widget (*maxcol*,) for flow sizing -- the parent chooses only the number of columns for this widget () for fixed sizing -- this widget is a fixed size which can't be adjusted by the parent :type size: widget size :param focus: set to ``True`` if this widget or one of its children is in focus :type focus: bool :returns: A :class:`Canvas` subclass instance containing the rendered content of this widget :class:`Text` widgets return a :class:`TextCanvas` (arbitrary text and display attributes), :class:`SolidFill` widgets return a :class:`SolidCanvas` (a single character repeated across the whole surface) and container widgets return a :class:`CompositeCanvas` (one or more other canvases arranged arbitrarily). If *focus* is ``False``, the returned canvas may not have a cursor position set. There is some metaclass magic defined in the :class:`Widget` metaclass :class:`WidgetMeta` that causes the result of this method to be cached by :class:`CanvasCache`. Later calls will automatically look up the value in the cache first. As a small optimization the class variable :attr:`ignore_focus` may be defined and set to ``True`` if this widget renders the same canvas regardless of the value of the *focus* parameter. Any time the content of a widget changes it should call :meth:`_invalidate` to remove any cached canvases, or the widget may render the cached canvas instead of creating a new one. )rrrts r%rz Widget.render s X"!r&)rYNone)r rrYr)rYrI)rYzfrozenset[Sizing]rH)r9(tuple[()] | tuple[int] | tuple[int, int]r?rIrYztuple[int, int])rYr\)rYz Widget | NonerW)rYz list[str])rYzdict[str, typing.Any]r9rrstrrYz str | None)r9rrrrrZrrZrrZr?rIrYz bool | None)r9rr?rIrYr)r'r(r)r*rkrrrsrrqrnr _command_maprrerirlrorupropertyrwr?r|focus_positionrrrrrrr0r&r%r\r\s8l\Kfjj&,,?@GLb%5 *@&PS  N "6  4'6'' '  '  '' 'X,"6,","  ,"r&r\) metaclassc$|rtd|y)z[ raise ValueError if size != (). Used by FixedWidgets to test size parameter. z+FixedWidget takes only () for size.passed: N) ValueError)r9s r% fixed_sizer8s  FthOPP r&c@t|Gfddt}|S)z Return a mixin class that delegates all standard widget methods to an attribute given by attribute_name. This mixin is designed to be used as a superclass of another widget. ceZdZUdgZded<ddfd Zedfd Zedfd Zedfd Z dfd Z edfd Z edfd Z e dfd Z edfd Zedfd Zy)7delegate_to_widget_mixin..DelegateToWidgetMixinrztyping.ClassVar[list[str]]rcL|j||}t|Sr>)rr)rEr9r?r: get_delegates r%rz>delegate_to_widget_mixin..DelegateToWidgetMixin.renderQs(%,,T,?D"4( (r&c(|jSrW)rlrErs r%rlzBdelegate_to_widget_mixin..DelegateToWidgetMixin.selectableUs%00 0r&c(|jSrW)get_cursor_coordsrs r%rzIdelegate_to_widget_mixin..DelegateToWidgetMixin.get_cursor_coordsYs %77 7r&c(|jSrW) get_pref_colrs r%rzDdelegate_to_widget_mixin..DelegateToWidgetMixin.get_pref_col^s %22 2r&c4|j||SrW)r)rEr9rrs r%rz@delegate_to_widget_mixin..DelegateToWidgetMixin.keypresscs%..tS9 9r&c(|jSrW)move_cursor_to_coordsrs r%rzMdelegate_to_widget_mixin..DelegateToWidgetMixin.move_cursor_to_coordsfs %;; ;r&c(|jSrW)rrs r%rz.DelegateToWidgetMixin.rowsk%** *r&c(|jSrW)rrs r%rzCdelegate_to_widget_mixin..DelegateToWidgetMixin.mouse_eventos  %11 1r&c(|jSrW)rors r%roz>delegate_to_widget_mixin..DelegateToWidgetMixin.sizingvs%,, ,r&c(|jSrW)rurs r%ruz.DelegateToWidgetMixin.packzrr&NrH)r?rIrYr)rYzCallable[[], bool])rYzLCallable[[tuple[()] | tuple[int] | tuple[int, int]], tuple[int, int] | None])rYz@Callable[[tuple[()] | tuple[int] | tuple[int, int]], int | None]r)rYzFCallable[[[tuple[()] | tuple[int] | tuple[int, int], int, int]], bool])rYz!Callable[[tuple[int], bool], int])rYz[Callable[[tuple[()] | tuple[int] | tuple[int, int], str, int, int, int, bool], bool | None])rYzCallable[[], frozenset[Sizing]])rYzKCallable[[tuple[()] | tuple[int] | tuple[int, int], bool], tuple[int, int]])r'r(r)r__annotations__rrrlrrrrrrroru)rsr%DelegateToWidgetMixinrNs06x,7 )  1  1  8  8  3  3 :  <  <  +  +  2 h 2  2  -  -  +  +r&r)rr\)attribute_namerrs @r%delegate_to_widget_mixinrBs$n-L.+.+` ! r&c eZdZy)WidgetWrapErrorN)r'r(r)r0r&r%rrsr&rc`eZdZdfd ZeddZej ddZddZxZS) WidgetWrapct|t|tsN|jj d|jj }tj|dtd||_ y)a9 w -- widget to wrap, stored as self._w This object will pass the functions defined in Widget interface definition to self._w. The purpose of this widget is to provide a base class for widgets that compose other widgets for their display and behaviour. The details of that composition should not affect users of the subclass. The subclass may decide to expose some of the wrapped widgets by behaving like a ContainerWidget or WidgetDecoration, or it may hide them from outside access. r^z is not subclass of WidgetrN) rr isinstancer\r$r(r'rrDeprecationWarning_wrapped_widget)rEwobj_class_pathr$s r%rzWidgetWrap.__init__sh !V$ ! 6 67q9M9M8NON MM!""<="  !r&c|jSrW)rrbs r%_wz WidgetWrap._ws###r&c2||_|jy)a Change the wrapped widget. This is meant to be called only by subclasses. >>> size = (10,) >>> ww = WidgetWrap(Edit("hello? ", "hi")) >>> ww.render(size).text # ... = b in Python 3 [...'hello? hi '] >>> ww.selectable() True >>> ww._w = Text("goodbye") # calls _set_w() >>> ww.render(size).text [...'goodbye '] >>> ww.selectable() False N)rre)rE new_widgets r%rz WidgetWrap._ws$ * r&cjtjdtd||_|j y)a Change the wrapped widget. This is meant to be called only by subclasses. >>> from urwid import Edit, Text >>> size = (10,) >>> ww = WidgetWrap(Edit("hello? ", "hi")) >>> ww.render(size).text # ... = b in Python 3 [...'hello? hi '] >>> ww.selectable() True >>> ww._w = Text("goodbye") # calls _set_w() >>> ww.render(size).text [...'goodbye '] >>> ww.selectable() False zg_set_w is deprecated. Please use 'WidgetWrap._w' property directly. API will be removed in version 5.0.rrN)rrrrre)rErs r%_set_wzWidgetWrap._set_ws/"  u  ! r&)rrrYr)rYr)rrrYr) r'r(r)rrrsetterrr+r,s@r%rrs9!0$$YY(r&rrc,ddl}|jy)Nr)doctesttestmod)rs r%_testrs OOr&__main__)r9z tuple[()]rYr)rrrYz type[Widget])1 __future__rrKr_typingroperatorrurwidr urwid.canvasrrrurwid.command_mapr urwid.split_reprr urwid.utilr constantsr TYPE_CHECKINGcollections.abcrrTypeVarrr`r'r MetaSignalsr Exceptionr.Warningr2r;rrrTrr\rrrGenericrrr0r&r%rs*# ==)'  2/   8 $ !$$i !F")"$G$ 6,(({"z{"| Q<!~ i I)*;[IX  z Gr&