^ j!5 dZddlmZddlmZmZmZmZmZGddZ GddZ Gdd Z Gd d e Z Gd d e Z Gdde ZGdde ZGdde ZdS)zRun list encoding utilities.) annotations)AnyCallable GeneratorIterableIteratorc"eZdZdZd dZd d Zd S)_Run)countvaluer rr intreturnNonec"||_||_dSNr r )selfr r s N/home/agentuser/manim-venv/lib/python3.11/site-packages/pyglet/text/runlist.py__init__z _Run.__init__ s  strc(d|jd|jdS)NzRun(z, )rrs r__repr__z _Run.__repr__ s1dj11DJ1111rN)r rr r rrrr)__name__ __module__ __qualname__ __slots__rrrrr r sA"I222222rr cdeZdZUdZded<dgZdd Zdd ZddZddZ d dZ d!dZ d"dZ d#dZ dS)$RunListaList of contiguous runs of values. A `RunList` is an efficient encoding of a sequence of values. For example, the sequence ``aaaabbccccc`` is encoded as ``(4, a), (2, b), (5, c)``. The class provides methods for modifying and querying the run list without needing to deal with the tricky cases of splitting and merging the run list entries. Run lists are used to represent formatted character data in pyglet. A separate run list is maintained for each style attribute, for example, weight, italic, font size, and so on. Unless you are overriding the document interfaces, the only interaction with run lists is via `RunIterator`. The length and ranges of a run list always refer to the character positions in the decoded list. For example, in the above sequence, ``set_run(2, 5, 'x')`` would change the sequence to ``aaxxxbccccc``. z list[_Run]runssizer initialrrrc2t||g|_dS)zCreate a run list of the given size and a default value. Args: size: Number of characters to represent initially. initial: The value of all characters in the run list. N)r r$)rr%r&s rrzRunList.__init__'s'4(() rposlengthcd}|jD]4}||cxkr||jzkrnn|xj|z c_||jz }5dS)aZInsert characters into the run list. The inserted characters will take on the value immediately preceding the insertion point (or the value of the first character, if `pos` is 0). Args: pos: Insertion index length: Number of characters to insert. rN)r$r )rr(r)iruns rinsertzRunList.insert3si 9  CC((((1sy=((((( V# NAA  rstartendcRd}|jD]b}||z dkrnV||cxkr||jzkr6nn3t||z ||jz|z }|xj|zc_||z}||jz }cd|jD|_|jst|jdg|_dSdS)zRemove characters from the run list. Args: start: Starting index to remove from. end: End index, exclusive. rc(g|]}|jdk |Srr .0rs r z"RunList.delete..[9991QWq[[Q[[[rN)r$r minr r )rr.r/r+r,trims rdeletezRunList.deleteGs 9  CU{aE****Q]*****3;CI (=>> T! t  NAA99 999 y -ci++,DIII - -rr cd||z dkrdSd}d}d}d}d}t|jD]E\} } | j} ||cxkr || zkr nn| }||z }||cxkr || zkr nn| }||z }|| z }F|]|j|} |j|t | j|| xj|zc_|||kr||z}|dz }|K|j|} |j|t | j|| xj|zc_d}|jD]'} ||kr|| jz|kr|| _|| jz }(|jd} |jddD]0} | j| jkr| xj| jz c_d| _| } 1d|jD|_dS)zSet the value of a range of characters. Args: start: Start index of range. end: End of range, exclusive. value: Value to set over the range. rNc(g|]}|jdk |Sr2r3r4s rr7z#RunList.set_run..r8r) enumerater$r r-r r ) rr.r/r r+start_i start_trimend_iend_trimrun_ir,r last_runs rset_runzRunList.set_runas3 ;!   F  #DI..  JE3IE5$$$$1u9$$$$$"QY 3""""U"""""7 JAA  )G$C I  Wd39j&A&A B B B II #II G## *H   )E"C I  UDH$=$= > > > II !II 9  Czza#)ms22! NAA9Q<9QRR=  CyHN** X^+ !"HH:9 999 r*Generator[tuple[int, int, Any], Any, None]c#^Kd}|jD] }|||jz|jfV||jz }!dSNr)r$r r )rr+r,s r__iter__zRunList.__iter__sN 9  CQ]CI- - - - NAA  r RunIteratorc t|S)z+Get an extended iterator over the run list.)rKrs rget_run_iteratorzRunList.get_run_iterators4   rindexcd}|jD]-}||cxkr||jzkr nn |jcS||jz }.||kr|jdjSt)zGet the value at a character position. Args: index: Index of character. Must be within range and non-negative. r)r$r r IndexError)rrNr+r,s r __getitem__zRunList.__getitem__s} 9  CE))))A M)))))y   NAA A::9R=& &rrc:tt|Sr)rlistrs rrzRunList.__repr__s4::rN)r%r r&rrr)r(r r)r rr)r.r r/r rr)r.r r/r r rrrrrG)rrKrNr rrr)rrr__doc____annotations__r rr-r;rFrJrMrRrr!rrr#r#s$I * * * *(----4=:=:=:=:~ !!!!(rr#c"eZdZdZd dZd d Zd S)AbstractRunIteratoraRange iteration over `RunList`. `AbstractRunIterator` objects allow any monotonically non-decreasing access of the iteration, including repeated iteration over the same index. Use the ``[index]`` operator to get the value at a particular index within the document. For example:: run_iter = iter(run_list) value = run_iter[0] value = run_iter[0] # non-decreasing access is OK value = run_iter[15] value = run_iter[17] value = run_iter[16] # this is illegal, the index decreased. Using `AbstractRunIterator` to access increasing indices of the value runs is more efficient than calling `RunList.__getitem__` repeatedly. You can also iterate over monotonically non-decreasing ranges over the iteration. For example:: run_iter = iter(run_list) for start, end, value in run_iter.ranges(0, 20): pass for start, end, value in run_iter.ranges(25, 30): pass for start, end, value in run_iter.ranges(30, 40): pass Both start and end indices of the slice are required and must be positive. rNr rrc td)zGet the value at a given index. See the class documentation for examples of valid usage. Args: index: Document position to query. abstractNotImplementedErrorrrNs rrRzAbstractRunIterator.__getitem__s"*---rr.r/+Generator[tuple[int, int, Any], None, None]c td)aAIterate over a subrange of the run list. See the class documentation for examples of valid usage. Args: start: Start index to iterate from. end: End index, exclusive. Returns: Iterator over (start, end, value) tuples. r\r]rr.r/s rrangeszAbstractRunIterator.rangess"*---rNrVr.r r/r rr`)rrrrWrRrcr!rrrZrZsF> . . . .......rrZc:eZdZUded<ddZdd Zdd ZddZdS)rKzIterator[AbstractRunIterator]_run_list_iterrun_list'Iterable[AbstractRunIterator] | RunListrrcrt||_t|\|_|_|_dSr)iterrfnextr.r/r )rrgs rrzRunIterator.__init__s,"8nn+/::( DHdjjjrrZc*t|jSr)rkrfrs r__next__zRunIterator.__next__sD'(((rrNr rc ||jkrC||jkr8t|\|_|_|_||jkr ||jk8|jS#t$rt wxYwr)r/r.rkr StopIterationrQr_s rrRzRunIterator.__getitem__s~ 48## (:(:37::0 DHdj48## (:(::      s AAA)r.r/r`c#K ||jkr-t|\|_|_|_||jk-|t |j||jfV||jkrSt|\|_|_|_|jt |j||jfV||jkQdSdS#t $rYdSwxYwr)r/rkr.r r9rorbs rrczRunIterator.rangess 48##37::0 DHdj48##TXs++TZ7 7 7 7..37::0 DHdjj#dh"4"4dj@@@@......    FF sB3B;; C C N)rgrhrr)rrZrVrd)rrrrXrrmrRrcr!rrrKrKsr11116666))))      rrKc*eZdZdZdd Zdd ZddZdS)OverriddenRunIteratorzPIterator over a `RunIterator`, with a value temporarily replacing a given range. base_iteratorrZr.r r/r rrrc>||_||_||_||_dS)a4Create a derived iterator. Args: base_iterator: Source of runs. start: Start of range to override end: End of range to override, exclusive value: Value to replace over the range N)rjoverride_start override_endoverride_value)rrsr.r/r s rrzOverriddenRunIterator.__init__ s)" ##rr`c#K||jks ||jkr$|j||D]}|VdS||jcxkr|kr*nn'|j||jD]}|Vt |j|t |j||jfV||jcxkr|kr+ndS|j|j|D]}|VdSdSr)rurvrjrcmaxr9rw)rr.r/r6s rrczOverriddenRunIterator.ranges3sR $% % %$2C)C)CY%%eS11    t*0000S00000))%1DEEAGGGGt*E22t(#..&( ( ( (t(....3......))$*;SAAAGGGG/.rrNc^|j|cxkr |jkr nn|jS|j|Sr)rurvrwrjr_s rrRz!OverriddenRunIterator.__getitem__Ds@  % ; ; ; ;$*; ; ; ; ; ;& &yrN) rsrZr.r r/r r rrrrdrVrrrrWrrcrRr!rrrrrrsVZZ$$$$&"      rrrc*eZdZdZdd ZddZddZdS)FilteredRunIteratorzWIterate over an `AbstractRunIterator` with filtered values replaced by a default value.rsrZ filter_funcCallable[[Any], bool]defaultrrrc0||_||_||_dS)aCreate a filtered run iterator. Args: base_iterator: Source of runs. filter_func: Function taking a value as parameter, and returning ``True`` if the value is acceptable, and ``False`` if the default value should be substituted. default: Default value to replace filtered values. Nrjfilterr)rrsr~rs rrzFilteredRunIterator.__init__Ns" !  rr.r r/r`c#K|j||D]/\}}}||r|||fV#|||jfV0dSr)rjrcrr)rr.r/start_end_r s rrczFilteredRunIterator.ranges`sz#'9#3#3E3#?#? 1 1 FD%{{5!! 1dE)))))dDL00000  1 1rrNcX|j|}||r|S|jSrr)rrNr s rrRzFilteredRunIterator.__getitem__gs/ %  ;;u   L|rN)rsrZr~rrrrrrdrVr{r!rrr}r}KsVaa$1111rr}c6eZdZUdZded<ddZdd ZddZdS)ZipRunIteratorz1Iterate over multiple run iterators concurrently.tuple[RunIterator, ...]range_iteratorsrrc||_dS)zCreate a zipped run iterator. Args: range_iterators: A tuple of ranged iterators. Nr)rrs rrzZipRunIterator.__init__rs /rr.r r/r`c#K fd|jD}td|D\}}}t|}t|}t|}kr]t|}||fV|t |D]-\}} |||krt | \||<||<||<.k[dSdS#t $rYdSwxYw)Nc<g|]}|Sr!)rc)r5r+r/r.s rr7z)ZipRunIterator.ranges..~s'LLL!%--LLLrc,g|]}t|Sr!)rk)r5r+s rr7z)ZipRunIterator.ranges..s(D(D(DQa(D(D(Dr)rziprTr9r?rkro) rr.r/ iteratorsstartsendsvaluesmin_endr+iterators `` rrczZipRunIterator.ranges|s LLLLLt7KLLLI#&(D(D)(D(D(D#E FD&&\\F::D&\\F#++d))Wf,,,,#,Y#7#7GGKAxAw'))8.s777Q%777rrr_s `rrRzZipRunIterator.__getitem__s 7777$"67777rN)rrrrrdrV)rrrrWrXrrcrRr!rrrrnsd;;,,,,////"888888rrcReZdZUdZded<ded<ded<dd Zdd ZddZddZdS)ConstRunIteratorz9Iterate over a constant value without creating a RunList.r r)r/rr rrc0||_||_||_dSr)r)r/r )rr)r s rrzConstRunIterator.__init__s  rrGc#,Kd|j|jfVdSrI)r)r rs rrmzConstRunIterator.__next__s#dj((((((rr.r`c#"K|||jfVdSrr rbs rrczConstRunIterator.rangess!S$*$$$$$$rrNc|jSrrr_s rrRzConstRunIterator.__getitem__s zrN)r)r r rrrrUrdrV) rrrrWrXrrmrcrRr!rrrrsCCKKK HHHJJJ ))))%%%%rrN)rW __future__rtypingrrrrrr r#rZrKrrr}rrr!rrrs""""""""??????????????22222222nnnnnnnnb9.9.9.9.9.9.9.9.x%>+ + + + + /+ + + \     -   F 8 8 8 8 8( 8 8 8F*r