(ph K8SrSSKrSSKJrJr SSKJrJr \R"5S:XaSSK r OSSK r Sr \ "5r \ "SR55r"SS \5r"S S \5r"S S \5r"SS\5r"SS\5rSrSrSrSrSrg)z3Sub-module providing sequence-formatting functions.N)TextType StringType) CGA_COLORSX11_COLORNAMES_TO_RGBWindowsc2[5n[HPnURU5 URSU-5 URSU-5 URSU-5 MR [H(nURU5 URSU-5 M* U$)zd 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 E/var/www/html/venv/lib/python3.13/site-packages/blessed/formatters.py _make_colorsrsUF  9 59$% 9y() <)+,  +  9 59$%+ Mz,bold underline reverse blink italic standoutc(\rSrSrSrSSjrSrSrg)ParameterizingString1a 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' cJ[R"X5nX$lX4lU$)z 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). )r__new___normal_name)clscapnormalnamenews rrParameterizingString.__new__>s#s(   rc [R"URS5/UQ76RS5n[ X R 5$![ aFnU(a9[US[5(a![ SUR<SU<SU<35eeSnAf[Ra$nS[U5;ae[5sSnA$SnAff=f)a 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 isinstancerrerrorrNullCallableString)selfargsattrerrs r__call__ParameterizingString.__call__Ls (<< H 5==DDXND#D,,7 7  47J77.2jj$EFF || ('hsm;%' '  (s+A A CABC.C C CNz__name__ __module__ __qualname____firstlineno____doc__rr0__static_attributes__r2rrrr1s  #(rrc(\rSrSrSrSSjrSrSrg)ParameterizingProxyStringra 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' c[U[5(dU5e[US5(d US5e[R"XS5nUSUlX$lX4lU$)az 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)tuplecallablerr _fmt_argsrr)rfmt_pairrrrs rr!ParameterizingProxyString.__new__sh(E**4H4* $$1hqk1$sQK0      rcb[UR"UR"U66UR5$)ac 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'formatrCrr,r-s rr0"ParameterizingProxyString.__call__s,  T^^T-B C $ . .rr2Nr3r5r2rrr=r=rs.& .rr=c(\rSrSrSrSSjrSrSrg)r'a. 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' c>[R"X5nX#lU$)z Class constructor accepting 2 positional arguments. :arg str sequence: terminal attribute sequence. :arg str normal: terminating sequence for this attribute (optional). )rrr)rsequencerrs rrFormattingString.__new__ss-  rc [U5HVup#[U[5(aM[SU<SU<S[R<S[ U5R<35e SnU(afUR (aUUR nUR U-nUVs/sH-nURURUR 55PM/ nnUSRU5-U-$s snf)z Return ``text`` joined by ``sequence`` and ``normal``. :raises TypeError: Not a string type :rtype: str :returns: Arguments wrapped in sequence and normal z)TypeError for FormattingString argument, z, at position z: expected type z, got r4) enumerater)rr(r6typerjoinsplit)r,r-idxucs_partpostfix_refreshs rr0FormattingString.__call__s't_MCh 33$,c:3F3FXH_H_a-  DLLllG||d*H$(*$(MM(..">?$( *chhtn$w..*s4C,r2N)r4r5r2rrr'r's$ /rr'c*\rSrSrSrSrSrSrSrg)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' c>[R"X5nX#lU$)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))``. rr _callable)rdirecttargetrs rrFormattingOtherString.__new__ss+  rcP[R"[U5UR4$Nr])r,s r__getnewargs__$FormattingOtherString.__getnewargs__s$/??rc2U(aUR"U6$U$)zReturn ``text`` by ``target``.)r^rHs rr0FormattingOtherString.__call__ s(,t~~t$6$6rr2N) r6r7r8r9r:rrdr0r;r2rrrZrZs" @7rrZc$\rSrSrSrSrSrSrg)r+iz 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. c0[R"US5$)zClass constructor.r4)rr)rs rrNullCallableString.__new__sS))rcvU(a[US[5(a [5$SRU5$)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. rr4)r)intr+rRrHs rr0NullCallableString.__call__s0z$q'3//&' 'xx~rr2Nr5r2rrr+r+s*rr+c ^[[U4SjS55T5n[SS4TRU5[SS4TRU5S.[SS 4TRU5[S S 4TRU5[SS 4TRU5[SS 4TRU5SSS.S.nUR U05R US5$)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. c3l># UH)nTRRU5(dM%Uv M+ g7frc)kind startswith).0_kindterms r #get_proxy_string..Bs,:-@E!YY11%8 %-@s$4 4)screenansiz[{0}GcUSS-4$Nrr@r2args r"get_proxy_string..HSVaZMrz[{0}dcUSS-4$rzr2r{s rr}r~Jrr)hpavpaz[?25lcgNr2r2r{s rr}r~PBrz[?25hcgrr2r{s rr}r~RrrcUSS-4$rzr2r{s rr}r~TrrcUSS-4$rzr2r{s rr}r~Vrrzz)civiscnormrrscrcN)nextiterr=rget)rtr. term_kind _proxy_tables` rget_proxy_stringr5sT:-@::;?AI -9:DKKO,9:DKKO  //dD./dD,9:DKKO,9:DKKO  L.   Ir * . .tT ::rc/n/SQnURS5H6nU(aUSU;aUS==SU-- ss'M%URU5 M8 U$)a. 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_)rSappend)compound merged_segsmergeable_prefixessegments rsplit_compoundr^sYK6>>#& ;r?.@@ OsW} ,O   w ' ' rcUR(dg[R"URR X55nUcS$UR S5$)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 r4r") does_stylingr#tigetstr_sugarrr&)rtr.vals rresolve_capabilityrusE    //$++//$5 6C+373::h#77rcURS:Xa [5$SU;a URO URnUR SS5SnU[ ;aaSU;aSOSnUR SS5SnSUR 5<3nU"[[U5U-5n[X`R5$U[;d S U45e[UnURS ::a*U"UR"U65n[X`R5$SU;aS OS nURS :XdeSU-S-n[UR"U6UR5$)aE 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` rr rr@rr COLOR_zcolor not known4838iz;2;{0};{1};{2}m)number_of_colorsr+_background_color_foreground_colorrsplitruppergetattrr#r'rrrgb_downconvertrG) rtcolor vga_color_cap base_coloroffsetr.fmt_attrrgbfgbg_seqs r resolve_colorrs_" !!##05~T++++c1%b)JZ 5(a\\#q)"- '--/1 !6!?@++66 . .':1'' .  +C # !5!5s!;<++66 DH  G ++ +("%66H HOOS14;; ??rc^U[;a [TU5$U[;a"[TU5n[ UTR 5$[ U5n[SU55(a1U4SjU5n[ SRU5TR 5$[TU5nU(d*[TTRRX55nUbU$[UTR U5$)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` c3R# UHo[;=(d U[;v M g7frc)COLORS COMPOUNDABLES)rrfmts rru$resolve_attribute..s Ijs6M 1SM1 1js%'c3<># UHn[TU5v M g7frc)resolve_attribute)rrrrts rrursIjs'c22jsr4) rrrrr'rrallrRrrrr)rtr.rM formatters resolution tparm_capseqproxys` rrrs  v~T4(( }%dD1$++66  %J Ij IIIIjI  4dkkBB &dD1L !!%!<>  L  dkk4 @@r)r:platformblessed._compatrrblessed.colorspacerrsystemjinxedr#rrr rSrrr=r'rZr+rrrrrr2rrrs91@ ?? !2 BHHJK >(8>(B8.8.v9/x9/x$7H$7N""J&;R.8&2@j.Ar