k:iLUdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl m Z m Z ddl mZddlmZmZmZmZmZmZmZmZmZmZmZmZddlmZdd lmZ m!Z"m#Z$m%Z&dd l'm(Z(ed eZd e)d<edZ*edZ+GddeZ,GddeZ-GddeZ.GddZ/Gddee*e+fZ0e1e&jde&jfgZ4GddZ5Gdde5Z6Gdd eZ7Gd!d"e5Z8Gd#d$eZ9Gd%d&Z:y)'a pyte.screens ~~~~~~~~~~~~ This module provides classes for terminal screens, currently it contains three screens with different features: * :class:`~pyte.screens.Screen` -- base screen implementation, which handles all the core escape sequences, recognized by :class:`~pyte.streams.Stream`. * If you need a screen to keep track of the changed lines (which you probably do need) -- use :class:`~pyte.screens.DiffScreen`. * If you also want a screen to collect history and allow pagination -- :class:`pyte.screen.HistoryScreen` is here for ya ;) .. note:: It would be nice to split those features into mixin classes, rather than subclasses, but it's not obvious how to do -- feel free to submit a pull request. :copyright: (c) 2011-2012 by Selectel. :copyright: (c) 2012-2017 by pyte authors and contributors, see AUTHORS for details. :license: LGPL, see LICENSE for more details. ) annotationsN)deque defaultdict) lru_cache) AnyCallable DefaultDictDict GeneratorList NamedTupleOptionalSetSequenceTextIOTypeVar)wcwidth)charsetscontrolgraphicsmodes)Streami)maxsizezCallable[[str], int]rKTVTc&eZdZUdZded<ded<y)Marginsz(A container for screen's scroll margins.inttopbottomN__name__ __module__ __qualname____doc____annotations__C/var/www/html/bot/venv/lib/python3.12/site-packages/pyte/screens.pyrr7s2 H Kr)rcNeZdZUdZded<ded<ded<ded<d ed <d ed <y ) SavepointzAA container for savepoint, created on :data:`~pyte.escape.DECSC`.Cursorcursorstr g0_charset g1_charsetrcharsetbooloriginwrapNr"r(r)r*r,r,<s#K NOO L L Jr)r,ceZdZUdZded<dZded<dZded<dZded <dZded <dZ ded <dZ ded <dZ ded <dZ ded<y)CharaA single styled on-screen character. :param str data: unicode character. Invariant: ``len(data) == 1``. :param str fg: foreground colour. Defaults to ``"default"``. :param str bg: background colour. Defaults to ``"default"``. :param bool bold: flag for rendering the character using bold font. Defaults to ``False``. :param bool italics: flag for rendering the character using italic font. Defaults to ``False``. :param bool underscore: flag for rendering the character underlined. Defaults to ``False``. :param bool strikethrough: flag for rendering the character with a strike-through line. Defaults to ``False``. :param bool reverse: flag for swapping foreground and background colours during rendering. Defaults to ``False``. :param bool blink: flag for rendering the character blinked. Defaults to ``False``. r/datadefaultfgbgFr3bolditalics underscore strikethroughreverseblinkN) r#r$r%r&r'r:r;r<r=r>r?r@rAr(r)r*r7r7Fs^$ IBBD$GTJM4GTE4r)r7c,eZdZdZdZedfddZy)r-a Screen cursor. :param int x: 0-based horizontal cursor position. :param int y: 0-based vertical cursor position. :param pyte.screens.Char attrs: cursor attributes (see :meth:`~pyte.screens.Screen.select_graphic_rendition` for details). xyattrshidden c<||_||_||_d|_y)NFrC)selfrDrErFs r*__init__zCursor.__init__os  r)N)rDrrErrFr7returnNone)r#r$r%r& __slots__r7rKr(r)r*r-r-ds.I59#Yr)r-c eZdZdZddZddZy)StaticDefaultDictaA :func:`dict` with a static default value. Unlike :func:`collections.defaultdict` this implementation does not implicitly update the mapping when queried with a missing key. >>> d = StaticDefaultDict(42) >>> d["foo"] 42 >>> d {} c||_yNr9)rJr9s r*rKzStaticDefaultDict.__init__s  r)c|jSrRrS)rJkeys r* __missing__zStaticDefaultDict.__missing__s ||r)N)r9rrLrM)rUrrLr)r#r$r%r&rKrVr(r)r*rPrPvs r)rPceZdZdZed5dZd6dZd7dZed8dZd9dZ d:d;dZ d:dd Zd9d Zd9dZd?dZd@dZd@dZd9dZd9dZd9dZd9dZd9dZd9dZd9dZd9dZdAdBdZdAdBdZdAdBdZdAdBdZdAdBdZ dCdDdZ!dEdFd Z"d9d!Z#dEdGd"Z$d9d#Z%dAdHd$Z&dAdBd%Z'dAdBd&Z(dAdBd'Z)dAdBd(Z*dAdBd)Z+dAdBd*Z,d:dId+Z-dAdJd,Z.dAdKd-Z/dLd.Z0d9d/Z1dMd0Z2dEdNd1Z3dOd2Z4d?d3Z5dPd4Z6y)QScreena A screen is an in-memory matrix of characters that represents the screen display of the terminal. It can be instantiated on its own and given explicit commands, or it can be attached to a stream and will respond to events. .. attribute:: buffer A sparse ``lines x columns`` :class:`~pyte.screens.Char` matrix. .. attribute:: dirty A set of line numbers, which should be re-drawn. The user is responsible for clearing this set when changes have been applied. >>> screen = Screen(80, 24) >>> screen.dirty.clear() >>> screen.draw("!") >>> list(screen.dirty) [0] .. versionadded:: 0.7.0 .. attribute:: cursor Reference to the :class:`~pyte.screens.Cursor` object, holding cursor position and attributes. .. attribute:: margins Margins determine which screen lines move during scrolling (see :meth:`index` and :meth:`reverse_index`). Characters added outside the scrolling region do not make the screen to scroll. The value is ``None`` if margins are set to screen boundaries, otherwise -- a pair 0-based top and bottom line indices. .. attribute:: charset Current charset number; can be either ``0`` or ``1`` for `G0` and `G1` respectively, note that `G0` is activated by default. .. note:: According to ``ECMA-48`` standard, **lines and columns are 1-indexed**, so, for instance ``ESC [ 10;10 f`` really means -- move cursor to position (9, 9) in the display matrix. .. versionchanged:: 0.4.7 .. warning:: :data:`~pyte.modes.LNM` is reset by default, to match VT220 specification. Unfortunately this makes :mod:`pyte` fail ``vttest`` for cursor movement. .. versionchanged:: 0.4.8 .. warning:: If `DECAWM` mode is set than a cursor will be wrapped to the **beginning** of the next line, which is the behaviour described in ``man console_codes``. .. seealso:: `Standard ECMA-48, Section 6.1.1 `_ for a description of the presentational component, implemented by ``Screen``. cXtj|jv}tddd|S)zAAn empty character with default foreground and background colors.rHr9)r8r:r;r@)moDECSCNMmoder7)rJr@s r* default_charzScreen.default_chars'** )y'JJr)cg_|_|_tfd_t _jtj_ d_ y)NcHtttfjSrR)rPrr7r]rJsr*z!Screen.__init__..s,SdehjnenSoptqBqBTCr)) savepointscolumnslinesrbuffersetdirtyreset _DEFAULT_MODEcopyr\margins)rJrcrds` r*rKzScreen.__init__sV+-  ?JLC@D "u  !&&( *. r)cxdj|jj|j|jS)Nz {0}({1}, {2}))format __class__r#rcrdr`s r*__repr__zScreen.__repr__s0&&t~~'>'>'+||TZZA Br)c dfd }tjDcgc]&}dj|j|(c}Scc}w)z2A :func:`list` of screen lines as unicode strings.c 3Kd}tjD]L}|rd}||j}tt t |dddk(sJt |ddk(}|Nyw)NFrr)rangercr8summapr)line is_wide_charrDcharrJs r*renderzScreen.display..renderst L4<<( #(LAw||3wQR12a777&tAw/14   sA(A+)rvzStaticDefaultDict[int, Char]rLzGenerator[str, None, None])rsrdjoinre)rJryrEs` r*displayzScreen.displays= :?tzz9JKAt{{1~./KKKs+A c|jjt|j|jj d|_tj|_ d|_ d|_ d|_ tj|_tj |_t%td|j&d|_t+dd|_|j/d|_y)a}Reset the terminal to its initial state. * Scrolling margins are reset to screen boundaries. * Cursor is moved to home location -- ``(0, 0)`` and its attributes are set to defaults (see :attr:`default_char`). * Screen is cleared -- each character is reset to :attr:`default_char`. * Tabstops are reset to "every eight columns". * All lines are marked as :attr:`dirty`. .. note:: Neither VT220 nor VT102 manuals mention that terminal modes and tabstops should be reset as well, thanks to :manpage:`xterm` -- we now know that. Nrzr)rgupdatersrdreclearrkrirjr\title icon_namer2csLAT1_MAPr0 VT100_MAPr1rfrctabstopsr-r.cursor_position saved_columnsr`s r*rhz Screen.resets" % +,  !&&(   ++,, E!T\\156 Ql  ,0r)Nc||xs |j}|xs |j}||jk(r||jk(ry|jjt |||jkrP|j |j dd|j|j|z |j||jkrL|jjD]/}t ||jD]}|j|d1||c|_|_|jy)aResize the screen to the given size. If the requested screen size has more lines than the existing screen, lines will be added at the bottom. If the requested size has less lines than the existing screen lines will be clipped at the top of the screen. Similarly, if the existing screen has less columns than the requested screen, columns will be added at the right, and if it has more -- columns will be clipped at the right. :param int lines: number of lines in the new screen. :param int columns: number of columns in the new screen. .. versionchanged:: 0.7.0 If the requested screen size is identical to the current screen size, the method does nothing. Nr) rdrcrgrrs save_cursorr delete_linesrestore_cursorrevaluespop set_margins)rJrdrcrvrDs r*resizez Screen.resizes &#)T\\ DJJ 7dll#:  %,' 4::       A &   djj50 1    ! T\\ ! **, &w 5&AHHQ%& &$)'  DL r)c||dk(r |d|_y|jxstd|jdz }| |j}n&t dt |dz |jdz }| |j }n&t dt |dz |jdz }||z dk\r"t|||_|jyy)zSelect top and bottom margins for the scrolling region. :param int top: the smallest line number that is scrolled. :param int bottom: the biggest line number that is scrolled. Nrr)rkrrdr maxminr!r)rJr r!rks r*rzScreen.set_marginsGs K3!8DL ,,<'!TZZ!^"< ;++CaS1Wdjj1n56C >^^FC DJJN;#00 >A"1g..u.=DG> >  ) )" - :: "!%DKK  #56s F4c|tjvr=|dk(rtj||_y|dk(rtj||_yyy)aoDefine ``G0`` or ``G1`` charset. :param str code: character set code, should be a character from ``"B0UK"``, otherwise ignored. :param str mode: if ``"("`` ``G0`` charset is defined, if ``")"`` -- we operate on ``G1``. .. warning:: User-defined charsets are currently not supported. ()N)rMAPSr0r1)rJcoder\s r*define_charsetzScreen.define_charsetsE 277?s{"$''$-"$''$- r)cd|_y)zSelect ``G0`` character set.rNr2r`s r*shift_inzScreen.shift_in  r)cd|_y)zSelect ``G1`` character set.rNrr`s r* shift_outzScreen.shift_outrr)c|j|jr |jn |j}|D]}t |}|j j |jk(rtj|jvrP|jj|j j|j|jn$|dkDr|j xj |zc_tj |jvr|dkDr|j#||j$|j j}|dk(r?|j j&j)|||j j <n|dk(r|j j&j)|||j j <|j j dz|jkr|j j&j)d||j j dz<nV|dk(rNt+j,|r8|j j rl||j j dz }t+j.d|j0|z}|j)|||j j dz <n|j jr|j$|j jdz |jdz }t+j.d|j0|z}|j)||j$|j jdz |jdz <nnF|dkDsct3|j j |z|j|j _|jj|j jy)aDisplay decoded characters at the current cursor position and advances the cursor if :data:`~pyte.modes.DECAWM` is set. :param str data: text to display. .. versionchanged:: 0.5.0 Character width is taken into account. Specifically, zero-width and unprintable characters do not affect screen state. Full-width characters are rendered into two consecutive character containers. rrr8rrrzNFCN) translater2r1r0rr.rDrcrZDECAWMr\rgaddrEcarriage_returnlinefeedIRMinsert_charactersrerFr unicodedata combining normalizer8r)rJr8rx char_widthrvlast normalizeds r*drawz Screen.draws~~#||DOOB0 ND J {{}} ,99 )JJNN4;;==1((*MMO!^KKMMZ/M vv"zA~&&z2;;t{{}}-DQ&*kk&7&7&@&@d&@&KT[[]]#q&*kk&7&7&@&@d&@&KT[[]]#;;==1$t||3.2kk.?.?!r**+q[%:%:4%@;;==  12D!,!6!6udii$>N!OJ.2mmm.LD*+[[]];;t{{}}q'89$,,:JKD!,!6!6udii$>N!OJ : 6KK  124< M a0 Nd t{{}}%r)c||_y)zkSet terminal title. .. note:: This is an XTerm extension supported by the Linux terminal. N)rrJparams r* set_titlezScreen.set_titles  r)c||_y)zfSet icon name. .. note:: This is an XTerm extension supported by the Linux terminal. N)rrs r* set_icon_namezScreen.set_icon_names r)c&d|j_y)z5Move the cursor to the beginning of the current line.rN)r.rDr`s r*rzScreen.carriage_return#s  r)c|jxstd|jdz \}}|jj|k(r{|j j t|jt||D]!}|j|dz|j|<#|jj|dy|jy)zMove the cursor down one line in the same column. If the cursor is at the last line, create a new line at the bottom. rrN) rkrrdr.rErgrrsrer cursor_downrJr r!rEs r*indexz Screen.index'sll@gaa&@ V ;;==F " JJ  eDJJ/ 03' 4!%QU!3 A 4 KKOOFD )    r)c|jxstd|jdz \}}|jj|k(r||j j t|jt||dD]!}|j|dz |j|<#|jj|dy|jy)zMove the cursor up one line in the same column. If the cursor is at the first line, create a new line at the top. rrN) rkrrdr.rErgrrsrer cursor_uprs r* reverse_indexzScreen.reverse_index5sll@gaa&@ V ;;==C  JJ  eDJJ/ 063+ 4!%QU!3 A 4 KKOOC & NN r)c~|jtj|jvr|j yy)z\Perform an index and, if :data:`~pyte.modes.LNM` is set, a carriage return. N)rrZLNMr\rr`s r*rzScreen.linefeedCs. 66TYY   " r)ct|jD]}|jj|ks|}n|jdz }||j_y)zcMove to the next tab space, or the end of the screen if there aren't anymore left. rN)sortedrr.rDrc)rJstopcolumns r*tabz Screen.tabLsO4==) &D{{}}t# & \\A%F r)c$|jy)zuMove cursor to the left one or keep it in its position if it's at the beginning of the line already. N) cursor_backr`s r* backspacezScreen.backspaceYs r)c 4|jjttj|j|j |j |jtj|jvtj|jvy)z0Push the current cursor position onto the stack.N) rbappendr,rjr.r0r1r2rZrr\rr`s r*rzScreen.save_cursor_sa y4;;)?)-)-)-)+TYY)>)+dii)?  A Br)c(|jr|jj}|j|_|j|_|j|_|j r|j tj|jr|j tj|j|_ |j|jdy|jtj|jy)z[Set the current cursor position to whatever cursor is on top of the stack. T) use_marginsN)rbrr0r1r2r4rrZrr5rr.ensure_hboundsensure_vboundsrr)rJ savepoints r*rzScreen.restore_cursorhs ??++-I'22DO'22DO$,,DL bhh'~~ bii(#**DK    !   D  1 OOBHH %  "r)cD|xsd}|jxstd|jdz \}}||jjcxkr|krny|j j t|jj|jt||jjdz dD]S}||z|kr-||jvr|j||j||z<|jj|dU|jyy)zInsert the indicated # of lines at line with cursor. Lines displayed **at** and below the cursor move down. Lines moved past the bottom margin are lost. :param count: number of lines to insert. rrrN rkrrdr.rErgrrsrerrrJcountr r!rEs r* insert_lineszScreen.insert_liness ll@gaa&@ V $++-- )6 ) JJ  eDKKMM4::> ?64;;==1#4b9 )u9&1 +;-1[[^DKKE * 4( )  " *r)cd|xsd}|jxstd|jdz \}}||jjcxkr|krny|j j t|jj|jt|jj|dzD]d}||z|kr>||z|jvs|jj||z|j|<I|jj|df|jyy)a3Delete the indicated # of lines, starting at line with cursor. As lines are deleted, lines displayed below cursor move up. Lines added to bottom of screen have spaces with same character attributes as last line moved up. :param int count: number of lines to delete. rrNrrs r*rzScreen.delete_liness ll@gaa&@ V $++-- )6 ) JJ  eDKKMM4::> ?4;;==&1*5 -u9&5yDKK/)-U)C AKKOOAt,  -  " *r)cx|jj|jj|xsd}|j|jj}t |j |jjdz dD]1}||z|j kr |||||z<|j|d3y)aInsert the indicated # of blank characters at the cursor position. The cursor does not move and remains at the beginning of the inserted blank characters. Data on the line is shifted forward. :param int count: number of characters to insert. rrN) rgrr.rErersrcrDrrJrrvrDs r*rzScreen.insert_characterss t{{}}% {{4;;==)t||T[[]]Q%6; A5yDLL("&q'QY HHQ  r)c|jj|jj|xsd}|j|jj}t |jj |jD]I}||z|jkr#|j||z|j||<8|j|dKy)a.Delete the indicated # of characters, starting with the character at cursor position. When a character is deleted, all characters to the right of cursor move left. Character attributes move with the characters. :param int count: number of characters to delete. rN) rgrr.rErersrDrcrr]rs r*delete_characterszScreen.delete_characterss t{{}}% {{4;;==)t{{}}dll3 "A5yDLL(((1u9d.?.?@QD!  "r)c|jj|jj|xsd}|j|jj}t |jj t|jj |z|jD]}|jj||<y)a&Erase the indicated # of characters, starting with the character at cursor position. Character attributes are set cursor attributes. The cursor remains in the same position. :param int count: number of characters to erase. .. note:: Using cursor attributes for character attributes may seem illogical, but if recall that a terminal emulator emulates a type writer, it starts to make sense. The only way a type writer could erase a character is by typing over it. rN) rgrr.rErersrDrrcrFrs r*erase_characterszScreen.erase_characterss t{{}}% {{4;;==)t{{}}4;;==50$,,?A (Akk''DG (r)c|jj|jj|dk(r+t |jj |j }nB|dk(r#t |jj dz}n|dk(rt |j }|j|jj}D]}|jj||<y)a2Erase a line in a specific way. Character attributes are set to cursor attributes. :param int how: defines the way the line should be erased in: * ``0`` -- Erases from cursor to end of line, including cursor position. * ``1`` -- Erases from beginning of line to cursor, including cursor position. * ``2`` -- Erases complete line. :param bool private: when ``True`` only characters marked as erasable are affected **not implemented**. rrrrN) rgrr.rErsrDrcrerF)rJhowrintervalrvrDs r* erase_in_linezScreen.erase_in_lines t{{}}% !8T[[]]DLL9H AXT[[]]Q./H AXT\\*H{{4;;==) (Akk''DG (r)c|dk(r.t|jjdz|j}nD|dk(r t|jj}n|dk(s|dk(rt|j}|jj |D]1}|j |}|D]}|jj||<3|dk(s|dk(r|j|yy)aErases display in a specific way. Character attributes are set to cursor attributes. :param int how: defines the way the line should be erased in: * ``0`` -- Erases from cursor to end of screen, including cursor position. * ``1`` -- Erases from beginning of screen to cursor, including cursor position. * ``2`` and ``3`` -- Erases complete display. All lines are erased and changed to single-width. Cursor does not move. :param bool private: when ``True`` only characters marked as erasable are affected **not implemented**. .. versionchanged:: 0.8.1 The method accepts any number of positional arguments as some ``clear`` implementations include a ``;`` after the first parameter causing the stream to assume a ``0`` second parameter. rrrrN) rsr.rErdrgrrerFr)rJrargsrrrErvrDs r*rzScreen.erase_in_displays. !8T[[]]Q. ;H AXT[[]]+H AXTZZ(H (# ,A;;q>D ,++++Q , , !8sax   s # r)cb|jj|jjy)z-Set a horizontal tab stop at cursor position.N)rrr.rDr`s r* set_tab_stopzScreen.set_tab_stop's $++--(r)c|dk(r0|jj|jjy|dk(rt |_yy)aClear a horizontal tab stop. :param int how: defines a way the tab stop should be cleared: * ``0`` or nothing -- Clears a horizontal tab stop at cursor position. * ``3`` -- Clears all horizontal tab stops. rrN)rdiscardr.rDrf)rJrs r*clear_tab_stopzScreen.clear_tab_stop+s< !8 MM ! !$++-- 0 AXEDMr)cttd|jj|jdz |j_y)z5Ensure the cursor is within horizontal screen bounds.rrN)rrr.rDrcr`s r*rzScreen.ensure_hbounds;s,C4;;==14< r)cF|j||jy)zMove cursor up the indicated # of lines to column 1. Cursor stops at bottom margin. :param int count: number of lines to skip. N)rrrJrs r* cursor_up1zScreen.cursor_up1Ws u r)c|jxstd|jdz \}}t|jj |xsdz||j_y)zMove cursor down the indicated # of lines in same column. Cursor stops at bottom margin. :param int count: number of lines to skip. rrN)rkrrdrr.rE)rJr_topr!s r*rzScreen.cursor_down`sH ||Awq$**q.'A fDKKMMUZa8&A r)cF|j||jy)zMove cursor down the indicated # of lines to column 1. Cursor stops at bottom margin. :param int count: number of lines to skip. N)rrrs r* cursor_down1zScreen.cursor_down1is  r)c|jj|jk(r|jxjdzc_|jxj|xsdzc_|jy)zMove cursor left the indicated # of columns. Cursor stops at left margin. :param int count: number of columns to skip. rN)r.rDrcrrs r*rzScreen.cursor_backrsL ;;==DLL ( KKMMQ M !#  r)cj|jxj|xsdz c_|jy)zMove cursor right the indicated # of columns. Cursor stops at right margin. :param int count: number of columns to skip. rNr.rDrrs r*cursor_forwardzScreen.cursor_forwards& !#  r)c|xsddz }|xsddz }|jktj|jvrO||jjz }|jj|cxkr|jj ksyy||j _||j _|j|jy)a^Set the cursor to a specific `line` and `column`. Cursor is allowed to move out of the scrolling region only when :data:`~pyte.modes.DECOM` is reset, otherwise -- the position doesn't change. :param int line: line number to move the cursor to. :param int column: column number to move the cursor to. rN) rkrZrr\r r!r.rDrErr)rJrvrs r*rzScreen.cursor_positions+A" Q << #DII(= DLL$$ $D<<##tBt||/B/BBC    r)cT|xsddz |j_|jy)zMove cursor to a specific column in the current line. :param int column: column number to move the cursor to. rNr )rJrs r*cursor_to_columnzScreen.cursor_to_columns$  1)  r)c|xsddz |j_tj|jvrA|j J|jxj|j j z c_|jy)z{Move cursor to a specific line in the current column. :param int line: line number to move the cursor to. rN)r.rErZrr\rkr r)rJrvs r*cursor_to_linezScreen.cursor_to_linesc a  88tyy <<+ ++ KKMMT\\-- -M r)cy)zdBell stub -- the actual implementation should probably be provided by the end-user. Nr()rJrs r*bellz Screen.bellr)c,|jjt|jt|jD]N}t|jD]4}|j ||j d|j ||<6Py)z?Fills screen with uppercase E's for screen focus and alignment.ErN)rgrrsrdrcrer)rJrErDs r*alignment_displayzScreen.alignment_displays~ % +,tzz" IA4<<( I$(KKN1$5$>$>C$>$H Aq! I Ir)ci}|r|dk(r|j|j_ytt |}|r|j }|dk(r+|j |jjn|tjvrtj||d<n|tjvrtj||d<ne|tjvr,tj|}|jd||dd<n'|tjvr$|j tj|n|tjvr$|j tj| n|tj tj"fvr|tj k(rdnd} |j }|d k(r'|j }tj$|||<nE|d k(r@d j'|j |j |j ||<|r|jjj*d i||j_y#t($rYEwxYw)zaSet display attributes. :param list attrs: a list of display attributes to set. rNrr:r;+r)r:)r;rrrz{0:02x}{1:02x}{2:02x}r()r]r.rFrreversedrr_asdictgFG_ANSIBGBG_ANSITEXT startswith FG_AIXTERM BG_AIXTERMFG_256BG_256 FG_BG_256rm IndexErrorr) rJrFreplace attrs_listattrattr_strrUnms r*rzScreen.select_graphic_renditions  $ 1 1DKK  (5/* >>#Dqyt0088:;" ! $  ! $ 66$<(0(;(;C(@ %%!,,t"45%!,,t"45!((AHH--"ahh.dD "(AAv&NN,'({{1~ a(?'E'E&NN,jnn.> @P(R 7@7DKK--66AA "s5BI00 I<;I<c x|dk(r5|jds#|jtjdzyyy)zReport terminal identity. .. versionadded:: 0.5.0 .. versionchanged:: 0.7.0 If ``private`` keyword argument is set, the method does nothing. This behaviour is consistent with VT220 manual. rrz?6cN)rwrite_process_inputctrlCSI)rJr\rs r*report_device_attributeszScreen.report_device_attributess4 19VZZ 2  $ $TXX%5 639r)c|dk(r#|jtjdzy|dk(r|jjdz}|jj dz}t j|jvr'|jJ||jjz}|jtjdj||zyy)zReport terminal status or cursor position. :param int mode: if 5 -- terminal status, 6 -- cursor position, otherwise a noop. .. versionadded:: 0.5.0 r0nrNz{0};{1}R) r2r3r4r.rDrErZrr\rkr rm)rJr\rDrEs r*report_device_statuszScreen.report_device_status s 19  $ $TXX_ 5 QY !A !Axx499$||///T\\%%%  $ $TXX 0A0A!Q0G%G Hr)cy)zWrite data to the process running inside the terminal. By default is a noop. :param str data: text to write to the process ``stdin``. .. versionadded:: 0.5.0 Nr()rJr8s r*r2zScreen.write_process_inputrr)cy)zSEndpoint for unrecognized escape sequences. By default is a noop. Nr()rJrrs r*debugz Screen.debug'rr))rLr7)rcrrdrrLrMrLr/)rLz List[str]rLrM)NN)rd Optional[int]rcr?rLrM)r r?r!r?rLrM)rrrrrLrM)rr/r\r/rLrM)r8r/rLrM)rr/rLrMrR)rr?rLrM)rF)rrrr3rLrMrrrrrrrrLrM)rrrLrM)rzOptional[bool]rLrM)rvr?rr?rLrM)rr?rLrM)rvr?rLrM)rrrLrM)rFrrLrM)r\rrr3rLrM)r\rrLrMrrrrrLrM)7r#r$r%r&propertyr]rKror|rhrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rrrrrrrrr5r9r2r<r(r)r*rXrXs5DJKK /B L L&1P'R!#F''R%&N0 A&F  #  B#2#(#.""$(,(6%$N)" E =?B 6$ I.B` 7I(  r)rXc$eZdZdZdfd ZxZS) DiffScreena A screen subclass, which maintains a set of dirty lines in its :attr:`dirty` attribute. The end user is responsible for emptying a set, when a diff is applied. .. deprecated:: 0.7.0 The functionality contained in this class has been merged into :class:`~pyte.screens.Screen` and will be removed in 0.8.0. Please update your code accordingly. c`tjdttt||i|y)NzThe functionality of ``DiffScreen` has been merged into ``Screen`` and will be removed in 0.8.0. Please update your code accordingly.)warningswarnDeprecationWarningsuperrDrK)rJrrrns r*rKzDiffScreen.__init__:s-  %&8 : j$($9&9r)rA)r#r$r%r&rK __classcell__rns@r*rDrD.s ::r)rDc@eZdZUded<ded<ded<ded<ded<y ) Historyz#deque[StaticDefaultDict[int, Char]]r r!floatratiorsizepositionN)r#r$r%r'r(r)r*rMrMCs ,, // L IMr)rMceZdZdZeej Zejddgddfd Z ddZ dfd Z ddZ ddZ dd Zdfd Zddfd Zdfd Zdfd ZddZddZxZS) HistoryScreena!A :class:`~pyte.screens.Screen` subclass, which keeps track of screen history and allows pagination. This is not linux-specific, but still useful; see page 462 of VT520 User's Manual. :param int history: total number of history lines to keep; is split between top and bottom queues. :param int ratio: defines how much lines to scroll on :meth:`next_page` and :meth:`prev_page` calls. .. attribute:: history A pair of history queues for top and bottom margins accordingly; here's the overall screen structure:: [ 1: .......] [ 2: .......] <- top history [ 3: .......] ------------ [ 4: .......] s [ 5: .......] c [ 6: .......] r [ 7: .......] e [ 8: .......] e [ 9: .......] n ------------ [10: .......] [11: .......] <- bottom history [12: .......] .. note:: Don't forget to update :class:`~pyte.streams.Stream` class with appropriate escape sequences -- you can use any, since pagination protocol is not standardized, for example:: Stream.escape["N"] = "next_page" Stream.escape["P"] = "prev_page" next_page prev_pagectt|t|t||||_tt |||y)N)maxlen)rMrrNhistoryrIrSrK)rJrcrdrXrOrns r*rKzHistoryScreen.__init__us>uG4$G4$U|&& ( mT+GU;r)cdfd }|S)Nc\j|i|}j|SrR) before_event after_event)rrresulteventhandlerrJs r*innerz*HistoryScreen._make_wrapper..inners3   e $d-f-F   U #Mr))rrrrrLrr()rJr^r_r`s``` r* _make_wrapperzHistoryScreen._make_wrapper~s   r)ctt| |}|tjvrtj |||S|SrR)rIrS__getattribute___wrappedra)rJr-valuerns r*rczHistoryScreen.__getattribute__s<mT;DA =)) ) ..tT5A ALr)c|dvrm|jj|jjkr?|j|jj|jjkr>yyy)zEnsure a screen is at the bottom of the history buffer. :param str event: event name, for example ``"linefeed"``. rUrTN)rXrQrPrT)rJr^s r*r[zHistoryScreen.before_eventsV 2 2,,''$,,*;*;; ,,''$,,*;*;; 3r)cP|dvrG|jjD]*}|D]#}||jkDs|j|%,|jj |jj k(xrtj|jv |j_ y)zEnsure all lines on a screen have proper width (:attr:`columns`). Extra characters are truncated, missing characters are filled with whitespace. :param str event: event name, for example ``"linefeed"``. rgN) rerrcrrXrQrPrZrr\r.rG)rJr^rvrDs r*r\zHistoryScreen.after_events . . **, $$A4<<' $ $ LL ! !T\\%6%6 6 $ JJ$)) #  r)c|jjj|jjj|jj |jj |_y)NrQ)rXr rr!rrPr`s r*_reset_historyzHistoryScreen._reset_historysQ   !!#||,,dll6G6G,H r)cJtt| |jy)zOverloaded to reset screen history state: history position is reset to bottom of both queues; queues themselves are emptied. N)rIrSrhrk)rJrns r*rhzHistoryScreen.resets mT(* r)c`tt| |g|i||dk(r|jyy)z"Overloaded to reset history state.rN)rIrSrrk)rJrrrrns r*rzHistoryScreen.erase_in_displays4 mT3CI$I&I !8    ! r)c|jxstd|jdz \}}|jj|k(r2|j j j|j|tt|/y)z8Overloaded to update top history with the removed lines.rrN) rkrrdr.rErXr rrerIrSrrJr r!rns r*rzHistoryScreen.indexsbll@gaa&@ V ;;==F " LL   # #DKK$4 5 mT(*r)c|jxstd|jdz \}}|jj|k(r2|j j j|j|tt|/y)z;Overloaded to update bottom history with the removed lines.rrN) rkrrdr.rErXr!rrerIrSrros r*rzHistoryScreen.reverse_indexsbll@gaa&@ V ;;==C  LL   & &t{{6': ; mT02r)c jjjkDrjjrt t jjt tjjjjz}jjjfdtjdz j|z dz dDjjjj|z _tjdz |dz dD]!}j||z j|<#t|dz ddD]3}jjjj|<5t!tj_yyy)zMove the screen page up through the history buffer. Page size is defined by ``history.ratio``, so for instance ``ratio = .5`` means that half the screen is restored from history on page switch. c3<K|]}j|ywrRre.0rErJs r* z*HistoryScreen.prev_page..s#+J A+JrrrjN)rXrQrdr rlenrmathceilrOr! extendleftrsrrerrfrgrJmidrEs` r*rUzHistoryScreen.prev_pagesw << 4:: -$,,2B2Bc$,,**+$))DJJ1C1C$CDEGC LL   * *+JtzzA~tzzC/?!/CRH+J J <<4<<#8#83#>? L4::>37B7 6!%QW!5 A 637B+ 8!%!1!1!5!5!7 A 8U4::./DJ3C -r)c jjjjkrjjrt t jjt tjjjjz}jjjfdt|Djjjj|z_tj|z D]!}j||zj|<#tj|z jD]3}jjj!j|<5t#tj_yyy)z5Move the screen page down through the history buffer.c3<K|]}j|ywrRrsrts r*rvz*HistoryScreen.next_page..s#GqDKKN#GrwrjN)rXrQrPr!rrxrryrzrdrOr extendrsrrepopleftrfrgr|s` r*rTzHistoryScreen.next_pagesT << 4<<#4#4 49L9Lc$,,--.$))DJJ1C1C$CDEGC LL   # ##GE#J#G G<<4<<#8#83#>? L4::+, 6!%QW!5 A 64::+TZZ8 ?!%!4!4! A ?U4::./DJ:M 4r))dg?) rcrrdrrXrrOrNrLrM)r^r/r_Callable[..., Any]rLr)r-r/rLr)r^r/rLrMr>rr@)r#r$r%r&rfreventsrdrrKrarcr[r\rkrhrrrrUrTrJrKs@r*rSrSKsg%L6==!H OO[+./<! *I "+30.0r)rScReZdZUdZded<ded<ded<ed dZd dZd d Zy ) DebugEventzEvent dispatched to :class:`~pyte.screens.DebugScreen`. .. warning:: This is developer API with no backward compatibility guarantees. Use at your own risk! r/namerrrc8ttj|SrR)rjsonloads)rvs r* from_stringzDebugEvent.from_strings4::d+,,r)c,tj|SrR)rdumpsr`s r*__str__zDebugEvent.__str__ szz$r)cbt||j|ji|jS)z)Execute this event on a given ``screen``.)getattrrrr)rJscreens r*__call__zDebugEvent.__call__ s')wvtyy)499D DDr)N)rvr/rLrr=)rrXrLr) r#r$r%r&r' staticmethodrrrr(r)r*rrs5 I I K-- Er)rcNeZdZdZej dfddZddZdfd ZxZ S) DebugScreenaA screen which dumps a subset of the received events to a file. >>> import io >>> with io.StringIO() as buf: ... stream = Stream(DebugScreen(to=buf)) ... stream.feed("\x1b[1;24r\x1b[4l\x1b[24;1H\x1b[0;10m") ... print(buf.getvalue()) ... ... # doctest: +NORMALIZE_WHITESPACE ["set_margins", [1, 24], {}] ["reset_mode", [4], {}] ["cursor_position", [24, 1], {}] ["select_graphic_rendition", [0, 10], {}] :param file to: a file-like object to write debug information to. :param list only: a list of events you want to debug (empty by default, which means -- debug all events). .. warning:: This is developer API with no backward compatibility guarantees. Use at your own risk! r(c ||_||_yrR)toonly)rJrrs r*rKzDebugScreen.__init__*s r)cdfd }|S)Nc jjtt||jjttj yrR)rwriter/roslinesep)rrr-rJs r*wrapperz)DebugScreen.only_wrapper..wrapper/s9 GGMM#jtV<= > GGMM#bjj/ *r)rAr()rJr-rs`` r* only_wrapperzDebugScreen.only_wrapper.s +r)c|tjvrtt||S|j r||j vr|j |SdS)NcyrRr()rrs r*raz.DebugScreen.__getattribute__..;rr))rrrIrrcrr)rJr-rns r*rczDebugScreen.__getattribute__5sJ v}} $drs4# *zzzz'  7 $ 7 A A T] T]j  :<$RV &RYY +, _ _ D::*jl0Fl0^EE0)0)0r)