gfKdZddlZddlZddlmZmZej dk(rddlZnddlZdZ e Z e djZ GddejZGd d ejZGd d ejZGd dejZGddejZdZdZdZdZdZy)z3Sub-module providing sequence-formatting functions.N) CGA_COLORSX11_COLORNAMES_TO_RGBWindowsc*t}tD]O}|j||jd|z|jd|z|jd|zQtD]'}|j||jd|z)|S)zt Return set of valid colors and their derivatives. :rtype: set :returns: Color names with prefixes on_bright_ on_bright_)setraddr)colors cga_color vga_colors j/var/dept/share/cheung/public_html/OutSchool/python/env/lib/python3.12/site-packages/blessed/formatters.py _make_colorsrsUF -  9 59$% 9y() <)+, -+&  9 59$%& Mz,bold underline reverse blink italic standoutceZdZdZddZdZy)ParameterizingStringa: A Unicode string which can be called as a parameterizing termcap. For example:: >>> from blessed import Terminal >>> term = Terminal() >>> color = ParameterizingString(term.color, term.normal, 'color') >>> color(9)('color #9') u'\x1b[91mcolor #9\x1b(B\x1b[m' cbtjj||}||_||_|S)a Class constructor accepting 3 positional arguments. :arg str cap: parameterized string suitable for curses.tparm() :arg str normal: terminating sequence for this capability (optional). :arg str name: name of this terminal capability (optional). )six text_type__new___normal_name)clscapnormalnamenews rrzParameterizingString.__new__@s-mm##C-   rc  tj|jdg|jd}t ||j S#t $rC}|r;t|dtjrt d|jd|d|d}~wtj$r,}dtj|vrtcYd}~Sd}~wwxYw)a3 Returning :class:`FormattingString` instance for given parameters. Return evaluated terminal capability (self), receiving arguments ``*args``, followed by the terminating sequence (self.normal) into a :class:`FormattingString` capable of being called. :raises TypeError: Mismatch between capability and arguments :raises curses.error: :func:`curses.tparm` raised an exception :rtype: :class:`FormattingString` or :class:`NullCallableString` :returns: Callable string for given parameters latin1rzUnknown terminal capability, z, or, TypeError for arguments z: Nztparm() returned NULL)cursestparmencodedecodeFormattingStringr TypeError isinstancer string_typesrerrorrNullCallableString)selfargsattrerrs r__call__zParameterizingString.__call__Ns (<< H 5==DDXND#D$,,7 7  47C,<,<=.2jj$EFF || ('cmmC.@@%' '  (s*A A C>BC)!C CCNz__name__ __module__ __qualname____doc__rr/rrrr3s  #(rrceZdZdZddZdZy)ParameterizingProxyStringa+ A Unicode string which can be called to proxy missing termcap entries. This class supports the function :func:`get_proxy_string`, and mirrors the behavior of :class:`ParameterizingString`, except that instead of a capability name, receives a format string, and callable to filter the given positional ``*args`` of :meth:`ParameterizingProxyString.__call__` into a terminal sequence. For example:: >>> from blessed import Terminal >>> term = Terminal('screen') >>> hpa = ParameterizingString(term.hpa, term.normal, 'hpa') >>> hpa(9) u'' >>> fmt = u'\x1b[{0}G' >>> fmt_arg = lambda *arg: (arg[0] + 1,) >>> hpa = ParameterizingProxyString((fmt, fmt_arg), term.normal, 'hpa') >>> hpa(9) u'\x1b[10G' ct|tsJ|t|ds J|dtjj ||d}|d|_||_||_|S)a Class constructor accepting 4 positional arguments. :arg tuple fmt_pair: Two element tuple containing: - format string suitable for displaying terminal sequences - callable suitable for receiving __call__ arguments for formatting string :arg str normal: terminating sequence for this capability (optional). :arg str name: name of this terminal capability (optional). r) r'tuplecallablerrr _fmt_argsrr)rfmt_pairrrrs rrz!ParameterizingProxyString.__new__sl(E*4H4* $1hqk1$mm##C!5      rcbt|j|j||jS)a Returning :class:`FormattingString` instance for given parameters. Arguments are determined by the capability. For example, ``hpa`` (move_x) receives only a single integer, whereas ``cup`` (move) receives two integers. See documentation in terminfo(5) for the given capability. :rtype: FormattingString :returns: Callable string for given parameters )r%formatr>rr+r,s rr/z"ParameterizingProxyString.__call__s0  ^T^^T-B C $ . .rNr0r2r7rrr9r9ts.& .rr9ceZdZdZddZdZy)r%af A Unicode string which doubles as a callable. This is used for terminal attributes, so that it may be used both directly, or as a callable. When used directly, it simply emits the given terminal sequence. When used as a callable, it wraps the given (string) argument with the 2nd argument used by the class constructor:: >>> from blessed import Terminal >>> term = Terminal() >>> style = FormattingString(term.bright_blue, term.normal) >>> print(repr(style)) u'\x1b[94m' >>> style('Big Blue') u'\x1b[94mBig Blue\x1b(B\x1b[m' cTtjj||}||_|S)z Class constructor accepting 2 positional arguments. :arg str sequence: terminal attribute sequence. :arg str normal: terminating sequence for this attribute (optional). )rrrr)rsequencerrs rrzFormattingString.__new__s&mm##C2  rc t|D]o\}}t|tjr!dj dtjD}t d|d|d|dt |jd}|r^|jrR|j}|j|z}|Dcgc],}|j |j|j.}}|dj |z|zScc}w)z Return ``text`` joined by ``sequence`` and ``normal``. :raises TypeError: Not a string type :rtype: str :returns: Arguments wrapped in sequence and normal z, c34K|]}|jywN)r3).0_types r z,FormattingString.__call__..s*Xe5>>*Xsz)TypeError for FormattingString argument, z, at position z: expected type z, got r1) enumerater'rr(joinr&typer3rsplit)r+r,idxucs_partexpected_typespostfix_refreshs rr/zFormattingString.__call__s't_ :MCh(8(89!%*XsGWGW*X!X!)#~ $X 7 79:: : DLLllG||d*H$(* MM(..">?*D*chhtn$w..*s-1C7N)r1r2r7rrr%r%s$ /rr%c"eZdZdZdZdZdZy)FormattingOtherStringa A Unicode string which doubles as a callable for another sequence when called. This is used for the :meth:`~.Terminal.move_up`, ``down``, ``left``, and ``right()`` family of functions:: >>> from blessed import Terminal >>> term = Terminal() >>> move_right = FormattingOtherString(term.cuf1, term.cuf) >>> print(repr(move_right)) u'\x1b[C' >>> print(repr(move_right(666))) u'\x1b[666C' >>> print(repr(move_right())) u'\x1b[C' cTtjj||}||_|S)z Class constructor accepting 2 positional arguments. :arg str direct: capability name for direct formatting, eg ``('x' + term.right)``. :arg str target: capability name for callable, eg ``('x' + term.right(99))``. rrr _callable)rdirecttargetrs rrzFormattingOtherString.__new__s&mm##C0  rcvtjjtj||jfSrHrX)r+s r__getnewargs__z$FormattingOtherString.__getnewargs__ s&}}$$S]]D94>>IIrc(|r|j|S|S)zReturn ``text`` by ``target``.)rYrBs rr/zFormattingOtherString.__call__s(,~t~~t$6$6rN)r3r4r5r6rr]r/r7rrrVrVs" J7rrVceZdZdZdZdZy)r*z A dummy callable Unicode alternative to :class:`FormattingString`. This is used for colors on terminals that do not support colors, it is just a basic form of unicode that may also act as a callable. cBtjj|dS)zClass constructor.r1)rrr)rs rrzNullCallableString.__new__s}}$$S#..rcb|rt|dtr tSdj|S)a= Allow empty string to be callable, returning given string, if any. When called with an int as the first arg, return an empty Unicode. An int is a good hint that I am a :class:`ParameterizingString`, as there are only about half a dozen string-returning capabilities listed in terminfo(5) which accept non-int arguments, they are seldom used. When called with a non-int as the first arg (no no args at all), return the first arg, acting in place of :class:`FormattingString` without any attributes. rr1)r'intr*rMrBs rr/zNullCallableString.__call__ s-z$q'3/&' 'xx~rNr2r7rrr*r*s/rr*c ttfddD}tddfj|tddfj|dtdd fj|td d fj|tdd fj|tdd fj|dddd}|j |ij |dS)a Proxy and return callable string for proxied attributes. :arg Terminal term: :class:`~.Terminal` instance. :arg str attr: terminal capability name that may be proxied. :rtype: None or :class:`ParameterizingProxyString`. :returns: :class:`ParameterizingProxyString` for some attributes of some terminal types that support it, where the terminfo(5) database would otherwise come up empty, such as ``move_x`` attribute for ``term.kind`` of ``screen``. Otherwise, None. c3XK|]!}jj|r|#ywrH)kind startswith)rI_kindterms rrKz#get_proxy_string..Gs*:E!YY11%8 :s'*)screenansiz[{0}Gc|ddzfSNrr;r7args rz"get_proxy_string..MSVaZMrz[{0}dc|ddzfSrlr7rms rroz"get_proxy_string..Orpr)hpavpaz[?25lcyNr7r7rms rroz"get_proxy_string..Urz[?25hcyrur7rms rroz"get_proxy_string..Wrvrc|ddzfSrlr7rms rroz"get_proxy_string..Yrprc|ddzfSrlr7rms rroz"get_proxy_string..[rprzz)civiscnormrrrsscrcN)nextiterr9rget)rhr- term_kind _proxy_tables` rget_proxy_stringr:sT:-@::;?AI -9:DKKO,9:DKKO  //dD./dD,9:DKKO,9:DKKO  L.   Ir * . .tT ::rcg}gd}|jdD]-}|r|d|vr|dxxd|zz cc<|j|/|S)aN Split compound formating string into segments. >>> split_compound('bold_underline_bright_blue_on_red') ['bold', 'underline', 'bright_blue', 'on_red'] :arg str compound: a string that may contain compounds, separated by underline (``_``). :rtype: list :returns: List of formating string segments )onbright on_bright_)rOappend)compound merged_segsmergeable_prefixessegments rsplit_compoundrcs^K6>>#&( ;r?.@@ OsW} ,O   w ' ( rc|jsytj|jj ||}|dS|j dS)ak Resolve a raw terminal capability using :func:`tigetstr`. :arg Terminal term: :class:`~.Terminal` instance. :arg str attr: terminal capability name. :returns: string of the given terminal capability named by ``attr``, which may be empty (u'') if not found or not supported by the given :attr:`~.Terminal.kind`. :rtype: str r1r ) does_stylingr!tigetstr_sugarrr$)rhr-vals rresolve_capabilityrzsG    //$++//$5 6C+373::h#77rc|jdk(r tSd|vr |jn |j}|j ddd}|t vr_d|vrdnd}|j ddd}d|j }|tt||z}t||jS|tvs Jd |ft|}|jd kr+||j|}t||jSd|vrd nd }|jd k(sJd|zdz}t|j||jS)au Resolve a simple color name to a callable capability. This function supports :func:`resolve_attribute`. :arg Terminal term: :class:`~.Terminal` instance. :arg str color: any string found in set :const:`COLORS`. :returns: a string class instance which emits the terminal sequence for the given color, and may be used as a callable to wrap the given string with such sequence. :returns: :class:`NullCallableString` when :attr:`~.Terminal.number_of_colors` is 0, otherwise :class:`FormattingString`. :rtype: :class:`NullCallableString` or :class:`FormattingString` rrrr;rrCOLOR_zcolor not known4838iz;2;{0};{1};{2}m)number_of_colorsr*_background_color_foreground_colorrsplitruppergetattrr!r%rrrgb_downconvertrA) rhcolor vga_color_cap base_coloroffsetr-fmt_attrrgbfgbg_seqs r resolve_colorrsh" !!##05~T++++c1%b)JZ 5(a\\#q)"- '--/1 !6!?@$++66 . .':1'' .  +C # !5!5!5s!;<$++66 DH  G ++ +("%66H OHOOS14;; ??rc|tvr t|S|tvr"t|}t |j St |}td|Dr0fd|D}t dj|j St|}|s*tjj||}||St|j |S)a Resolve a terminal attribute name into a capability class. :arg Terminal term: :class:`~.Terminal` instance. :arg str attr: Sugary, ordinary, or compound formatted terminal capability, such as "red_on_white", "normal", "red", or "bold_on_black". :returns: a string class instance which emits the terminal sequence for the given terminal capability, or may be used as a callable to wrap the given string with such sequence. :returns: :class:`NullCallableString` when :attr:`~.Terminal.number_of_colors` is 0, otherwise :class:`FormattingString`. :rtype: :class:`NullCallableString` or :class:`FormattingString` c3@K|]}|tvxs|tvywrH)COLORS COMPOUNDABLES)rIfmts rrKz$resolve_attribute..s! IsC6M 1SM1 1 Isc36K|]}t|ywrH)resolve_attribute)rIrrhs rrKz$resolve_attribute..sIs'c2Isr1) rrrrr%rrallrMrrrr)rhr-rE formatters resolution tparm_capseqproxys` rrrs  v~T4(( }%dD1$++66  %J Ij IIIjI  4dkkBB &dD1L !!%t!<>  L  dkk4 @@r)r6platformrblessed.colorspacerrsystemjinxedr!rrr rOrrrr9r%rVr*rrrrrr7rrrs9 A8?? !2 BHHJK >(3==>(B8. 8.v;/s}};/|$7CMM$7N##L&;R.8&2@j.Ar