
    עiQ,                    X   d dl mZ d dlZd dlZd dlmZ d dlmZmZm	Z	m
Z
mZmZmZmZ d dlmZmZmZmZmZmZ d dlZddlmZ erddlmZmZ dd	lmZ  e
d
      Z G d de	e         Z G d de	e         Z  G d d      Z! G d d      Z"e G d de             Z#ddZ$dd	 	 	 	 	 ddZ%y)    )annotationsN)TracebackType)TYPE_CHECKINGAnyGenericTypeVarIteratorOptionalAsyncIteratorcast)SelfProtocol	TypeGuardoverride
get_originruntime_checkable   )extract_type_var_from_base)GeminiNextGenAPIClientAsyncGeminiNextGenAPIClient)FinalRequestOptions_Tc                      e Zd ZU dZded<   dZded<   ded<   dd		 	 	 	 	 	 	 	 	 dd
ZddZddZddZ	ddZ
ddZ	 	 	 	 	 	 	 	 ddZddZy)StreamzJProvides the core interface to iterate over a synchronous stream response.httpx.ResponseresponseNOptional[FinalRequestOptions]_optionsSSEBytesDecoder_decoderoptionsc                   || _         || _        || _        || _        |j	                         | _        | j                         | _        y Nr   _cast_to_clientr   _make_sse_decoderr    
__stream__	_iteratorselfcast_tor   clientr"   s        f/sites/domain-asset-master/.venv/lib/python3.12/site-packages/google/genai/_interactions/_streaming.py__init__zStream.__init__,   >     !002*    c                6    | j                   j                         S r$   )r*   __next__r,   s    r/   r4   zStream.__next__;   s    ~~&&((r2   c              #  6   K   | j                   D ]  }|  y wr$   r*   r,   items     r/   __iter__zStream.__iter__>   s     NN 	DJ	s   c              #     K   | j                   j                  | j                  j                               E d {    y 7 wr$   )r    
iter_bytesr   r5   s    r/   _iter_eventszStream._iter_eventsB   s+     ==++DMM,D,D,FGGGs   7A?Ac              #  n  K   t        t        | j                        }| j                  }| j                  j
                  }| j                         }	 |D ]:  }|j                  j                  d      r n ||j                         ||       < |j                          y # |j                          w xY wwNz[DONE])datar-   r   )r   r   r&   r   r'   _process_response_datar=   r@   
startswithjsoncloser,   r-   r   process_dataiteratorsses         r/   r)   zStream.__stream__E   s     sDMM*==||::$$&	 X88&&x0"
GhWW	X NNHNNs   AB5?B  B5 B22B5c                    | S r$    r5   s    r/   	__enter__zStream.__enter__U   s    r2   c                $    | j                          y r$   rD   r,   exc_typeexcexc_tbs       r/   __exit__zStream.__exit__X   s     	

r2   c                8    | j                   j                          yz
        Close the response and release the connection.

        Automatically called if the response body is read to completion.
        N)r   rD   r5   s    r/   rD   zStream.close`   s     	r2   )
r-   type[_T]r   r   r.   r   r"   r   returnNonerV   r   )rV   zIterator[_T])rV   Iterator[ServerSentEvent]rV   r   rO   ztype[BaseException] | NonerP   zBaseException | NonerQ   zTracebackType | NonerV   rW   rV   rW   )__name__
__module____qualname____doc____annotations__r   r0   r4   r:   r=   r)   rK   rR   rD   rJ   r2   r/   r   r   %   s    T.2H+2 26+ + !	+
 '+ /+ 
+)H , " %	
 
r2   r   c                      e Zd ZU dZded<   dZded<   ded<   dd		 	 	 	 	 	 	 	 	 dd
ZddZddZddZ	ddZ
ddZ	 	 	 	 	 	 	 	 ddZddZy)AsyncStreamzLProvides the core interface to iterate over an asynchronous stream response.r   r   Nr   r   zSSEDecoder | SSEBytesDecoderr    r!   c                   || _         || _        || _        || _        |j	                         | _        | j                         | _        y r$   r%   r+   s        r/   r0   zAsyncStream.__init__p   r1   r2   c                R   K   | j                   j                          d {   S 7 wr$   )r*   	__anext__r5   s    r/   rf   zAsyncStream.__anext__   s     ^^--////s   '%'c               H   K   | j                   2 3 d {   }| 7 
6 y wr$   r7   r8   s     r/   	__aiter__zAsyncStream.__aiter__   s&     .. 	 	$J	.s   "  " "c                  K   | j                   j                  | j                  j                               2 3 d {   }| 7 
6 y wr$   )r    aiter_bytesr   )r,   rH   s     r/   r=   zAsyncStream._iter_events   s?     224==3L3L3NO 	 	#I	Os%   4A	AAAA	AA	c                 K   t        t        | j                        }| j                  }| j                  j
                  }| j                         }	 |2 3 d {   }|j                  j                  d      r n ||j                         ||       C|j                          d {    y 7 W6 7 	# |j                          d {  7   w xY wwr?   )r   r   r&   r   r'   rA   r=   r@   rB   rC   acloserE   s         r/   r)   zAsyncStream.__stream__   s     sDMM*==||::$$&	$% X Xc88&&x0"
GhWW //###XX $(//###s`   ACB4 B0B.B0;B4 C(B2)C.B00B4 2C4CC	CCc                   K   | S wr$   rJ   r5   s    r/   
__aenter__zAsyncStream.__aenter__   s     s   c                @   K   | j                          d {    y 7 wr$   rM   rN   s       r/   	__aexit__zAsyncStream.__aexit__   s      jjls   c                T   K   | j                   j                          d{    y7 wrT   )r   rl   r5   s    r/   rD   zAsyncStream.close   s      mm""$$$s   (&()
r-   rU   r   r   r.   r   r"   r   rV   rW   rX   )rV   zAsyncIterator[_T])rV   AsyncIterator[ServerSentEvent]rZ   r[   r\   )r]   r^   r_   r`   ra   r   r0   rf   rh   r=   r)   rn   rp   rD   rJ   r2   r/   rc   rc   i   s    V.2H+2** 26+ + !	+
 ,+ /+ 
+0$ , " %	
 
%r2   rc   c                      e Zd Zddddd	 	 	 	 	 	 	 	 	 d
dZedd       Zedd       Zedd       Zedd       ZddZ	e
dd	       Zy)ServerSentEventNeventr@   idretryc               L    |d}|| _         || _        |xs d | _        || _        y )N )_id_data_event_retry)r,   rv   r@   rw   rx   s        r/   r0   zServerSentEvent.__init__   s.     <D
mtr2   c                    | j                   S r$   )r}   r5   s    r/   rv   zServerSentEvent.event       {{r2   c                    | j                   S r$   )r{   r5   s    r/   rw   zServerSentEvent.id   s    xxr2   c                    | j                   S r$   )r~   r5   s    r/   rx   zServerSentEvent.retry   r   r2   c                    | j                   S r$   )r|   r5   s    r/   r@   zServerSentEvent.data   s    zzr2   c                @    t        j                  | j                        S r$   )rC   loadsr@   r5   s    r/   rC   zServerSentEvent.json   s    zz$))$$r2   c           	     p    d| j                    d| j                   d| j                   d| j                   d	S )NzServerSentEvent(event=z, data=z, id=z, retry=)ru   r5   s    r/   __repr__zServerSentEvent.__repr__   s9    '

|7499+U477)S[\`\f\f[gghiir2   )
rv   
str | Noner@   r   rw   r   rx   
int | NonerV   rW   )rV   r   )rV   r   )rV   str)rV   r   )r]   r^   r_   r0   propertyrv   rw   rx   r@   rC   r   r   rJ   r2   r/   rt   rt      s     !   	
   
         % j jr2   rt   c                  f    e Zd ZU ded<   ded<   ded<   ded<   ddZdd	Zdd
ZddZddZddZ	y)
SSEDecoderz	list[str]r|   r   r}   r   r~   _last_event_idc                <    d | _         g | _        d | _        d | _        y r$   )r}   r|   r   r~   r5   s    r/   r0   zSSEDecoder.__init__   s    
"r2   c              #     K   | j                  |      D ]@  }|j                         D ]+  }|j                  d      }| j                  |      }|s(| - B yw)^Given an iterator that yields raw binary data, iterate over it & yield every event encounteredutf-8N)_iter_chunks
splitlinesdecoder,   rG   chunkraw_linelinerH   s         r/   r<   zSSEDecoder.iter_bytes   s\     &&x0 	E!,,. w/kk$'I		s   AA	Ac              #     K   d}|D ]6  }|j                  d      D ]  }||z  }|j                  d      s| d}! 8 |r| yyw)^Given an iterator that yields raw binary data, iterate over it and yield individual SSE chunksr2   Tkeependss   s   

s   

Nr   endswithr,   rG   r@   r   r   s        r/   r   zSSEDecoder._iter_chunks   sf      	E(($(7 ==!@AJD		 J s
   3AAc                  K   | j                  |      2 3 d{   }|j                         D ],  }|j                  d      }| j                  |      }|s(| . I7 D6 yw)r   Nr   )_aiter_chunksr   r   r   s         r/   rj   zSSEDecoder.aiter_bytes   se     --h7 	 	%!,,. w/kk$'I		7s+   A!AAA8A!A!AA!c                  K   d}|2 3 d{   }|j                  d      D ]   }||z  }|j                  d      s| d}" ?7 :6 |r| yyw)r   r2   NTr   r   r   r   s        r/   r   zSSEDecoder._aiter_chunks  sn     # 	 	%(($(7 ==!@AJD		8 J s*   AAAA,A
AA
Ac                z   |s| j                   s%| j                  s| j                  s| j                  y t	        | j                   dj                  | j                        | j                  | j                        }d | _         g | _        d | _        |S |j                  d      ry |j                  d      \  }}}|j                  d      r|dd  }|dk(  r|| _         y |dk(  r| j                  j                  |       y |dk(  rd	|v r	 y || _        y |d
k(  r	 t        |      | _        y 	 y # t        t        f$ r Y y w xY w)N
ru   : r   rv   r@   rw    rx   )r}   r|   r   r~   rt   joinrB   	partitionappendint	TypeError
ValueError)r,   r   rH   	fieldname_values         r/   r   zSSEDecoder.decode  sW    ;;tzz$:M:MRVR]R]Re!kkYYtzz*&&kk	C DKDJDKJ??3"nnS1	1eC !"IEDK   & JJe$  $u}  ',#  '!!%j   z*  s   D( (D:9D:Nr\   rG   Iterator[bytes]rV   rY   )rG   r   rV   r   rG   AsyncIterator[bytes]rV   rr   )rG   r   rV   r   )r   r   rV   zServerSentEvent | None)
r]   r^   r_   ra   r0   r<   r   rj   r   r   rJ   r2   r/   r   r      s8    

.r2   r   c                      e Zd ZddZddZy)r   c                     y)r   NrJ   r,   rG   s     r/   r<   zSSEBytesDecoder.iter_bytesB      r2   c                     y)zdGiven an async iterator that yields raw binary data, iterate over it & yield every event encounteredNrJ   r   s     r/   rj   zSSEBytesDecoder.aiter_bytesF  r   r2   Nr   r   )r]   r^   r_   r<   rj   rJ   r2   r/   r   r   @  s    r2   r   c                z    t        |       xs | }t        j                  |      xr t        |t        t
        f      S )zaTypeGuard for determining whether or not the given type is a subclass of `Stream` / `AsyncStream`)r   inspectisclass
issubclassr   rc   )typorigins     r/   is_stream_class_typer   K  s0    _#F??6"Pz&6;:O'PPr2   )failure_messagec          	     H    ddl m}m} t        | dt	        d||f      |      S )a  Given a type like `Stream[T]`, returns the generic type variable `T`.

    This also handles the case where a concrete subclass is given, e.g.
    ```py
    class MyStream(Stream[bytes]):
        ...

    extract_stream_chunk_type(MyStream) -> bytes
    ```
    r   )r   rc   r   ztuple[type, ...])indexgeneric_basesr   )_base_clientr   rc   r   r   )
stream_clsr   r   rc   s       r/   extract_stream_chunk_typer   Q  s-     2%-/DE'	 r2   )r   typerV   z;TypeGuard[type[Stream[object]] | type[AsyncStream[object]]])r   r   r   r   rV   r   )&
__future__r   rC   r   typesr   typingr   r   r   r   r	   r
   r   r   typing_extensionsr   r   r   r   r   r   httpx_utilsr   r'   r   r   _modelsr   r   r   rc   rt   r   r   r   r   rJ   r2   r/   <module>r      s   " #    ` ` ` ` `  .L, T]AWR[ AHB%'"+ B%J&j &jRf fR h  Q #'   
	r2   