
    hm4                    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 d dlmZmZmZmZmZmZ d dlZddlmZmZ ddlmZ erdd	lmZ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AsyncIteratorcast)SelfProtocol	TypeGuardoverride
get_originruntime_checkable   )
is_mappingextract_type_var_from_base)APIError)OpenAIAsyncOpenAI_Tc                      e Zd ZU dZded<   de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responseSSEBytesDecoder_decoderc                   || _         || _        || _        |j                         | _        | j                         | _        y Nr   _cast_to_client_make_sse_decoderr   
__stream__	_iteratorselfcast_tor   clients       M/var/www/Befach/backend/env/lib/python3.12/site-packages/openai/_streaming.py__init__zStream.__init__   7     !002*    c                6    | j                   j                         S r    )r&   __next__r(   s    r+   r0   zStream.__next__*   s    ~~&&((r.   c              #  6   K   | j                   D ]  }|  y wr    r&   r(   items     r+   __iter__zStream.__iter__-   s     NNDJ #s   c              #     K   | j                   j                  | j                  j                               E d {    y 7 wr    )r   
iter_bytesr   r1   s    r+   _iter_eventszStream._iter_events1   s+     ==++DMM,D,D,FGGGs   7A?Ac              #    K   t        t        | j                        }| j                  }| j                  j
                  }| j                         }|D ]  }|j                  j                  d      r n|j                  l|j                  j                  d      sQ|j                  j                  d      s6|j                  j                  d      s|j                  j                  d      r|j                         }t        |      ry|j                  d      rhd }|j                  d      }t        |      r|j                  d      }|rt        |t              sd}t        || j                  j                   |d   	       ||||
       =|j                         }|j                  dk(  rt        |      ry|j                  d      rhd }|j                  d      }t        |      r|j                  d      }|rt        |t              sd}t        || j                  j                   |d   	       |||j                  d||
        |D ]  }	 y w)N[DONE]	response.transcript.zimage_edit.zimage_generation.errormessage"An error occurred during streamingr?   requestbodydatar)   r   rE   eventr   r   r"   r   r#   _process_response_datar9   rE   
startswithrG   jsonr   get
isinstancestrr   rB   
r(   r)   r   process_dataiteratorsserE   r?   r>   _sses
             r+   r%   zStream.__stream__4   s    sDMM*==||::$$&Cxx""8,yy 		$$[1		$$]3		$$]3		$$%89xxzd#(9"G HHW-E!%("'))I"6"*Wc*B"F" ' $ 5 5!']  #gQQ xxz99'Jt,<'AR"G HHW-E!%("'))I"6"*Wc*B"F" ' $ 5 5!']  #		(JT[fnooY ^ D s   IIc                    | S r     r1   s    r+   	__enter__zStream.__enter__l   s    r.   c                $    | j                          y r    closer(   exc_typeexcexc_tbs       r+   __exit__zStream.__exit__o   s     	

r.   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   rY   r1   s    r+   rY   zStream.closew   s     	r.   N)r)   type[_T]r   r   r*   r   returnNonerb   r   )rb   zIterator[_T])rb   Iterator[ServerSentEvent]rb   r   r[   ztype[BaseException] | Noner\   zBaseException | Noner]   zTracebackType | Nonerb   rc   rb   rc   )__name__
__module____qualname____doc____annotations__r,   r0   r6   r9   r%   rV   r^   rY   rU   r.   r+   r   r      s    T+ + !	+
 + 
+)H6p, " %	
 
r.   r   c                      e Zd ZU dZded<   de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   zSSEDecoder | SSEBytesDecoderr   c                   || _         || _        || _        |j                         | _        | j                         | _        y r    r!   r'   s       r+   r,   zAsyncStream.__init__   r-   r.   c                R   K   | j                   j                          d {   S 7 wr    )r&   	__anext__r1   s    r+   rr   zAsyncStream.__anext__   s     ^^--////s   '%'c               H   K   | j                   2 3 d {   }| 7 
6 y wr    r3   r4   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(   rR   s     r+   r9   zAsyncStream._iter_events   s?     224==3L3L3NO 	 	#I	Os%   4A	AAAA	AA	c               j  K   t        t        | j                        }| j                  }| j                  j
                  }| j                         }|2 3 d {   }|j                  j                  d      r n|j                  6|j                  j                  d      s|j                  j                  d      r|j                         }t        |      ry|j                  d      rhd }|j                  d      }t        |      r|j                  d      }|rt        |t              sd}t        || j                  j                   |d          ||||       |j                         }|j                  dk(  rt        |      ry|j                  d      rhd }|j                  d      }t        |      r|j                  d      }|rt        |t              sd}t        || j                  j                   |d          |||j                  d	||       |2 3 d {   }	
7 6 7 
6 y w)
Nr;   r<   r=   r>   r?   r@   rA   rD   rF   rH   rO   s
             r+   r%   zAsyncStream.__stream__   s    sDMM*==||::$$&! '	p '	p#xx""8,yy CII$8$8$EI]I]^kIlxxzd#(9"G HHW-E!%("'))I"6"*Wc*B"F" ' $ 5 5!']  #gQQ xxz99'Jt,<'AR"G HHW-E!%("'))I"6"*Wc*B"F" ' $ 5 5!']  #		(JT[fnoo # 	 	$W'	pT	(sO   AH3H-H*H-GH3 H1$H/%H1(H3*H--H3/H11H3c                   K   | S wr    rU   r1   s    r+   
__aenter__zAsyncStream.__aenter__   s     s   c                @   K   | j                          d {    y 7 wr    rX   rZ   s       r+   	__aexit__zAsyncStream.__aexit__   s      jjls   c                T   K   | j                   j                          d{    y7 wr`   )r   acloser1   s    r+   rY   zAsyncStream.close   s      mm""$$$s   (&(N)r)   ra   r   r   r*   r   rb   rc   rd   )rb   zAsyncIterator[_T])rb   AsyncIterator[ServerSentEvent]rf   rg   rh   )ri   rj   rk   rl   rm   r,   rr   rt   r9   r%   ry   r{   rY   rU   r.   r+   ro   ro      s    V**+ + !	+
 + 
+01f, " %	
 
%r.   ro   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rG   rE   idretryc               L    |d}|| _         || _        |xs d | _        || _        y )N )_id_data_event_retry)r(   rG   rE   r   r   s        r+   r,   zServerSentEvent.__init__   s.     <D
mtr.   c                    | j                   S r    )r   r1   s    r+   rG   zServerSentEvent.event       {{r.   c                    | j                   S r    )r   r1   s    r+   r   zServerSentEvent.id   s    xxr.   c                    | j                   S r    )r   r1   s    r+   r   zServerSentEvent.retry   r   r.   c                    | j                   S r    )r   r1   s    r+   rE   zServerSentEvent.data  s    zzr.   c                @    t        j                  | j                        S r    )rK   loadsrE   r1   s    r+   rK   zServerSentEvent.json  s    zz$))$$r.   c           	     p    d| j                    d| j                   d| j                   d| j                   d	S )NzServerSentEvent(event=z, data=z, id=z, retry=)r   r1   s    r+   __repr__zServerSentEvent.__repr__
  s9    '

|7499+U477)S[\`\f\f[gghiir.   )
rG   
str | NonerE   r   r   r   r   
int | Nonerb   rc   )rb   r   )rb   r   )rb   rN   )rb   r   )ri   rj   rk   r,   propertyrG   r   r   rE   rK   r   r   rU   r.   r+   r   r      s     !   	
   
         % j jr.   r   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   r1   s    r+   r,   zSSEDecoder.__init__  s    
"r.   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(   rQ   chunkraw_linelinerR   s         r+   r8   zSSEDecoder.iter_bytes  sR     &&x0E!,,.w/kk$'I	 / 1s   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 chunksr.   Tkeependss   s   

s   

Nr   endswithr(   rQ   rE   r   r   s        r+   r   zSSEDecoder._iter_chunks%  s\     E(($(7==!@AJD	 8  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+   rv   zSSEDecoder.aiter_bytes1  s`     --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   r.   NTr   r   r   r   s        r+   r   zSSEDecoder._aiter_chunks;  si     # 	 	%(($(7==!@AJD	 8	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
r   : r   rG   rE   r    r   )r   r   r   r   r   joinrJ   	partitionappendint	TypeError
ValueError)r(   r   rR   	fieldname_values         r+   r   zSSEDecoder.decodeG  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:Nrh   rQ   Iterator[bytes]rb   re   )rQ   r   rb   r   rQ   AsyncIterator[bytes]rb   r~   )rQ   r   rb   r   )r   rN   rb   zServerSentEvent | None)
ri   rj   rk   rm   r,   r8   r   rv   r   r   rU   r.   r+   r   r     s8    

.r.   r   c                      e Zd ZddZddZy)r   c                     y)r   NrU   r(   rQ   s     r+   r8   zSSEBytesDecoder.iter_bytesz      r.   c                     y)zdGiven an async iterator that yields raw binary data, iterate over it & yield every event encounteredNrU   r   s     r+   rv   zSSEBytesDecoder.aiter_bytes~  r   r.   Nr   r   )ri   rj   rk   r8   rv   rU   r.   r+   r   r   x  s    r.   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   ro   )typorigins     r+   is_stream_class_typer     s0    _#F??6"Pz&6;:O'PPr.   )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   ro   r   ztuple[type, ...])indexgeneric_basesr   )_base_clientr   ro   r   r   )
stream_clsr   r   ro   s       r+   extract_stream_chunk_typer     s-     2%-/DE'	 r.   )r   typerb   z;TypeGuard[type[Stream[object]] | type[AsyncStream[object]]])r   r   r   r   rb   r   )&
__future__r   rK   r   typesr   typingr   r   r   r   r	   r
   r   typing_extensionsr   r   r   r   r   r   httpx_utilsr   r   _exceptionsr   r#   r   r   r   r   ro   r   r   r   r   r   rU   r.   r+   <module>r      s    "    V V V ` `  : !, T]gWR[ gTc%'"+ c%L&j &jRf fR h  Q #'   
	r.   