
    ]Og&                     *   S SK r S SKrS SKrS SKrS SKJrJrJrJ	r	J
r
  S SKJr  \R                  (       a  S SKJr  \R                   \\	/\4   r\R                   \R$                  \   /\4   r " S S\R(                  \   \R$                  \   5      rg)    N)RTT_coUU_co)NotSetOptionalc            
       .   \ rS rSrSrSMS\R                  \R                  \      SS4S jjr	SNS jr
S\4S	 jr\R                  S
\SS4S j5       r\R                  S
\S\4S j5       rS rS\4S jrS\R                  \   SS4S jr\R                  S\SS4S j5       r\R                  S\S\\\4   SS4S j5       rSMS jrS\R*                  \/\4   SS4S jrSSS\R0                  S\R0                  SS4S jr\R                  S\R4                  \   4S  j5       r\R                  S\\\4   S\4S! j5       r\4S" jrS\4S# jr\R                  SOS$ j5       r\R                  SPS& j5       rS' rSMS\R                  \   SS4S( jjr  SQS)\R                  \R*                  \/\R0                  4      S*\R@                  \RB                  \   \RD                  \   S4   SS4S+ jjr#S\R*                  \/\4   SS4S, jr$SRS- jr%S\R*                  \/\4   SS4S. jr&S\R                  \   4S/ jr'SSS0 jr(S1\R*                  \/\R                  \   4   SS4S2 jr)\R                  S)\R*                  \/\4   SS34S4 j5       r*\R                  S)\R*                  \/\4   S\R*                  \R                  \   /\+4   SS54S6 j5       r*SMS)\R*                  \/\+4   S\R                  \\\4      4S7 jjr*S1\R*                  \/\4   SS4S8 jr,S9\RZ                  \.   SS:4S; jr/\R                  S<\0\\4   S\4S= j5       r1\R                  S<\0\\4   S>\S\4S? j5       r1\2Rf                  4S@ jr1\R                  SA\SS4SB j5       r\R                  STSC\SA\SD\SS4SE jj5       rSQSF jrSUSG\R@                  \4\R*                  \/\R0                  4   4   SH\SS4SI jjr5SUSS%SH\SS%4SJ jjr6S\R*                  \/\4   SS4SK jr7SLr8g)VStream   z?
A stream is an iterable with utility methods to transform it.
Niterablereturnc                 :    Uc  Sn[        U5      U l        Xl        g )N )iter_it	_original)selfr   s     S/Users/admin/workspace/ai/Jarvis/env/lib/python3.13/site-packages/nr/util/stream.py__init__Stream.__init__   s    hH~DH3;N    Stream[T_co]c                     U $ Nr   r   s    r   __iter__Stream.__iter__   s    Kr   c                 :    S U l         [        U R                  5      $ r   )r   nextr   r   s    r   __next__Stream.__next__   s    DN>r   valc                     g r   r   r   r$   s     r   __getitem__Stream.__getitem__#   s    7:r   c                     g r   r   r&   s     r   r'   r(   &   s    +.r   c                 6   [        U[        5      (       a1  U R                  UR                  UR                  UR                  5      $ [        U[
        5      (       a  US:  a7  [        U 5       H  u  p#X!:X  d  M  Us  $    [        SR                  U5      5      e[        R                  " U [        U5      S9n[        U5      [        U5      :  a  [        SR                  U5      5      eUS   $ [        SR                  [        U 5      R                  5      5      e)Nr   z$Stream has no element at position {})maxlenz+{} object is only subscriptable with slices)
isinstanceslicestartstopstepint	enumerate
IndexErrorformatcollectionsdequeabslen	TypeErrortype__name__)r   r$   indexvaluequeues        r   r'   r(   )   s    #uZZ		388SXX66	C			%dOLE\L , ?FFsKLL!!$s3x8u:C AHHMN
NQxCJJ4PT:K^K^_``r   c                 ,    [        U R                  5      $ r   )r!   r   r   s    r   r!   Stream.next:   s    >r   itsc                 V    [        [        R                  " U R                  /UQ76 5      $ r   )r   	itertoolschainr   )r   rA   s     r   appendStream.append=   s    )//$((1S122r   nzStream[t.List[T_co]]c                     g r   r   )r   rG   s     r   batchStream.batch@   s    58r   	collectorz	Stream[R]c                     g r   r   )r   rG   rK   s      r   rI   rJ   C   s    ILr   c                    ^^^^ [        U R                  5      mTc  [        mUU4S jmUUU4S jn[        U" 5       5      $ )z
Convert the stream into a stream of batches of size *n*, where each element of the stream
contains the result of the *collector* after passing up to *n* elements of the original
stream into it.
c              3   ~   >#    U v   SnUT:  a   [        T5      v   US-  nUT:  a  M  g g ! [         a     g f = f7f)N   r!   StopIteration)firstcountr   rG   s     r   takeStream.batch.<locals>.takeQ   sM     keAI	X
 	
 AI  	
	s    =- ==
:=:=c               3   j   >#      [        T5      n T" T" U 5      5      v   M  ! [         a     g f = f7fr   rP   )rR   rK   r   rT   s    r   generate_batches&Stream.batch.<locals>.generate_batches[   s@     	x.% U$$   	
	s   3# 3
0303)r   r   listr   )r   rG   rK   rW   r   rT   s    `` @@r   rI   rJ   F   s8     DHH~Hi% "$%%r   	predicatez#t.Tuple[Stream[T_co], Stream[T_co]]c                     [         R                  " U R                  5      u  p#[        [         R                  " X5      5      [        [        X5      5      4$ )z
Use a predicate to partition items into false and true entries.
Returns a tuple of two streams with the first containing all elements
for which *pred* returned #False and the other containing all elements
where *pred* returned #True.
)rC   teer   r   filterfalsefilter)r   rZ   t1t2s       r   bipartitionStream.bipartitione   s=     ]]488$FB)''	67y@U9VVVr   r   zStream[t.Callable[..., R]]akwc                 F   ^^ [        UU4S jU R                   5       5      $ )z>
Calls every item in *iterable* with the specified arguments.
c              3   2   >#    U  H  o" T0 TD6v   M     g 7fr   r   ).0xrc   rd   s     r   	<genexpr>Stream.call.<locals>.<genexpr>u   s     0x!!Q+"+xs   r   r   )r   rc   rd   s    ``r   callStream.callp   s    
 0txx000r   c                     g r   r   r   s    r   collectStream.collectw   s    %(r   c                     g r   r   r   rK   s     r   ro   rp   z   s    9<r   c                     [        U[        5      (       a'  [        U R                  U5      (       a  U R                  $ U" U R                  5      $ )z(
Collects the stream into a collection.
)r,   r:   r   r   rr   s     r   ro   rp   }   s<    
 )T""z$..)'L'L ^^TXXr   c                 d    Sn  [        U R                  5        US-  nM  ! [         a     U$ f = f)zL
Returns the number of items in the stream. This fully consumes the stream.
r   rO   )r!   r   rQ   )r   rS   s     r   rS   Stream.count   sE    
 E
DHH~ qje   Ls   ! 
//c                     g r   r   ss    r   concatStream.concat       r   	Stream[T]c                     g r   r   rw   s    r   ry   rz      r{   r   c                 0   ^  U 4S jn[        U" 5       5      $ )zF
Concatenate all values in the stream into a single stream of values.
c               3      >#    T H3  n [         R                  " [         R                  U 5       H  nUv   M	     M5     g 7fr   )tcastIterable)itelementr   s     r   	generator Stream.concat.<locals>.generator   s.     "vvajj"-G- . s   ;>)r   )r   r   s   ` r   ry   rz      s    
 )+r   c                     Ub+  [        U5       H  n [        U R                  5        M      U $   [        U R                  5        M  ! [         a       U $ f = f! [         a     U $ f = f)zV
Consume the contents of the stream, up to *n* elements if the argument is specified.
)ranger!   r   rQ   )r   rG   _s      r   consumeStream.consume   s{    
 	}Qx!	
txx.  K 	
txx.   	
 K	  	
K	s"   AA 
AA
A('A(keyskipc                    ^ ^^ Uc  S mOUmS[         R                  [        SS4   4UU U4S jjn[        U" 5       5      $ )aB  
Yields unique items from *iterable* whilst preserving the original order. If *skip* is
specified, it must be a set or sequence of items to skip in the first place (ie. items to
exclude from the returned stream). The specified set/sequence is modified in-place. Using a
set is highly recommended for performance purposes.
Nc                     U $ r   r   rh   s    r   <lambda>!Stream.distinct.<locals>.<lambda>   s    1r   r   c               3     >#    Tc
  [        5       OTn [        U [        R                  5      (       a  U R                  OU R
                  nU R                  nTR                   H&  nT" U5      nU" U5      (       a  M  U" U5        Uv   M(     g 7fr   )setr,   r   
MutableSetaddrE   __contains__r   )seenmark_visitedcheck_visiteditemkey_valkey_funcr   r   s        r   r   "Stream.distinct.<locals>.generator   sl     lSUd!+D!,,!?!?TXXT[[l''m(($4.W%%
w
*	 s   A5B<B)r   	Generatorr   r   )r   r   r   r   r   s   ` ` @r   distinctStream.distinct   sD     {hhq{{4t#34   )+r   c                 T    [        [        R                  " XR                  5      5      $ r   )r   rC   	dropwhiler   r   rZ   s     r   r   Stream.dropwhile       )%%i:;;r   c                 :    [        S U R                   5       5      $ )Nc              3   .   #    U  H  oc  M  Uv   M     g 7fr   r   )rg   rh   s     r   ri   "Stream.dropnone.<locals>.<genexpr>   s     7X!!Xs   	rk   r   s    r   dropnoneStream.dropnone   s    7TXX777r   c                 B   ^ [        U4S jU R                   5       5      $ )z4
Agnostic to Python's built-in `filter()` function.
c              3   F   >#    U  H  nT" U5      (       d  M  Uv   M     g 7fr   r   )rg   rh   rZ   s     r   ri    Stream.filter.<locals>.<genexpr>   s     6X1!!Xs   !	!rk   r   s    `r   r^   Stream.filter   s    
 6TXX666r   c                 D     U R                  5       $ ! [         a     gf = f)z5
Returns the first element of the stream, or `None`.
NrP   r   s    r   rR   Stream.first   s%    
YY[ s    
c                 :    SSK Jn  U" U R                  5       5      $ )z;
Returns the first element of the stream as an `Optional`.
r   r	   )nr.util.optionalr
   rR   )r   r
   s     r   firstoptStream.firstopt   s    
 *DJJL!!r   funcc                 l   ^ ^ S[         R                  [        SS4   4UU 4S jjn[        U" 5       5      $ )z)
Same as #map() but flattens the result.
r   Nc               3   Z   >#    TR                    H  n T" U 5       H  nUv   M	     M     g 7fr   )r   )rh   yr   r   s     r   r   !Stream.flatmap.<locals>.generator   s'     xx!aA'  s   (+)r   r   r   r   )r   r   r   s   `` r   flatmapStream.flatmap   s2    
q{{1dD=1   )+r   z$Stream[t.Tuple[R, t.Iterable[T_co]]]c                     g r   r   )r   r   s     r   groupbyStream.groupby  s    [^r   zStream[t.Tuple[R, U]]c                     g r   r   )r   r   rK   s      r   r   r     s    z}r   c                    ^ ^^ Tc*  [        [        R                  " T R                  T5      5      $ UUU 4S jn[        U" 5       5      $ )Nc               3      >#    Tc   e[         R                  " TR                  T5       H  u  pU T" U5      4v   M     g 7fr   )rC   r   r   )kgrK   r   r   s     r   r   !Stream.groupby.<locals>.generator  s=     $$$%%dhh4DA9Q<
 5s   =A )r   rC   r   r   )r   r   rK   r   s   ``` r   r   r   	  s9    I%%dhh455 
 IK  r   c                 B   ^ [        U4S jU R                   5       5      $ )z1
Agnostic to Python's built-in `map()` function.
c              3   4   >#    U  H  nT" U5      v   M     g 7fr   r   )rg   rh   r   s     r   ri   Stream.map.<locals>.<genexpr>  s     ,8a$q''8s   rk   )r   r   s    `r   map
Stream.map  s    
 ,488,,,r   r:   zStream[U_co]c                 B   ^ [        U4S jU R                   5       5      $ )z
Filters using #isinstance().
c              3   N   >#    U  H  n[        UT5      (       d  M  Uv   M     g 7fr   )r,   )rg   rh   r:   s     r   ri   !Stream.of_type.<locals>.<genexpr>   s     =XAt)<!!Xs   %	%rk   )r   r:   s    `r   of_typeStream.of_type  s    
 =TXX===r   
aggregatorc                     g r   r   )r   r   s     r   reduceStream.reduce"  s    @Cr   initialc                     g r   r   r   r   r   s      r   r   r   %  s    FIr   c                     U[         R                  L a   [        R                  " XR                  5      $ [        R                  " XR                  U5      $ r   )r   Value	functoolsr   r   r   s      r   r   r   (  s:    &,,j((33j((G<<r   r/   c                     g r   r   )r   r/   s     r   r-   Stream.slice.  s    03r   r.   r0   c                     g r   r   r   r.   r/   r0   s       r   r-   r   1  s    KNr   c                 X    [        [        R                  " U R                  XU5      5      $ r   )r   rC   islicer   r   s       r   r-   r   4  s     )""488U$?@@r   byreversec                    ^ [        U[        5      (       a  UmU4S jn[        R                  " [        R                  [
        /[        R                  4   U5      n[        [        U R                  XS95      $ )a  
Creates a new sorted stream. Internally the #sorted() built-in function is used so a new list
will be created temporarily.

# Parameters
by (str, callable): Specify by which dimension to sort the stream. If a string is specified,
  it will be used to retrieve a key or attribute from the values in the stream. In the case of
  a callable, it will be used directly as the `key` argument to #sorted().
c                 d   > [        U [        R                  5      (       a  U T   $ [        U T5      $ r   )r,   r   Mappinggetattr)r   lookup_attrs    r   r   Stream.sortby.<locals>.byD  s,    dAII&&k"
"{+
+r   )r   r   )
r,   strr   r   Callabler   Anyr   sortedr   )r   r   r   r   s      @r   sortbyStream.sortby7  sW     "ck, 


D6155=)2	.B&r;<<r   c                 (    U R                  S U5      $ )Nc                     U $ r   r   r   s    r   r   Stream.sort.<locals>.<lambda>N  s    r   )r   )r   r   s     r   sortStream.sortM  s    ;;{G,,r   c                 T    [        [        R                  " XR                  5      5      $ r   )r   rC   	takewhiler   r   s     r   r   Stream.takewhileP  r   r   )r   r   r   )r   r   )rx   Stream[str]r   r   )rx   zStream[t.Iterable[T]]r   r|   )NN)r   zStream[t.Optional[T_co]]r   r   )r   zOptional[T_co])rO   )F)9r;   
__module____qualname____firstlineno____doc__r   r
   r   r   r   r   r"   overloadr-   r'   r1   r!   rE   rI   	Collectorr   r   boolra   r   rl   Listro   rY   rS   ry   r   Unionr   MutableSequencer   r   r   r^   rR   r   r   r   r   r   Typer   r   
Aggregatorr   r   r   r   r   r   r   __static_attributes__r   r   r   r   r      s   <qzz!**T*:; <t <  :::U:~: :::.S.T. .a"D 3D) 3n 3 ::8S838 8::LSLYtQw%7LKL L&>	W1::tfdl#; 	W@e 	W1- 1155 1 1+ 1 ::(qvvd|( (::<yq1<a< <" 
S  ::  :: 	qzz# . ( 26GK	
AJJvquu}-	.
''!,,t$a&7&7&=tC
D 8<TFDL!9 <n <87ajj$6 7> 7QZZ% "	!**dVQZZ]%:; 	 	 ::^TFAI.^3Y^ ^::}TFAI.}1::qzzRVGWFXZ[F[;\}ax} }	!TFAI. 	!1::iPTVWPWFX;Y 	!-ajj$+ - ->!&&, >> > ::Cz$*5C$C C::Iz!T'2IQI1I I'-|| = ::333 3::NNCNsN>N NA=qwwsAJJvquu}$==> = =Zh =,- -t - -<TFDL!9 <n <r   r   )r5   r   rC   typingr   nr.util.genericr   r   r   r   r   nr.util.singletonr   TYPE_CHECKINGr   r
   r   r  r   r   Genericr   r   r   r   <module>r	     sx        / / $??'ZZA	"
JJ

1)*	@<QYYt_ajj. @<r   