File: //usr/local/lib/python3.10/dist-packages/openai/__pycache__/_response.cpython-310.pyc
o
���gGs � @ s� U d dl mZ d dlZd dlZd dlZd dlZd dlZd dlmZ d dl m
Z
m Z m Z m
Z
mZmZmZmZmZmZ d dlmZmZmZmZ d dlZd dlZd dlZddl m Z ddl m Z m Z m!Z!m"Z"m#Z# dd l$m%Z%m&Z&m'Z' dd
l(m)Z)m*Z* dd l+m,Z,m-Z-m.Z.m/Z/ dd l0m1Z1m2Z2 e
r�dd
l$m3Z3 ddl4m5Z5 ed�Z6ed�Z7ed�Z8eddd�Z9eddd�Z:e�;e<�Z=de>d< G dd� de
e7 �Z?G dd � d e?e7 �Z@G d d � d e?e7 �ZAG d d � d e@eB �ZCG d!d"� d"eAeB �ZDG d#d$� d$e@eB �ZEG d%d&� d&eAeB �ZFG d'd(� d(eG�ZHG d)d*� d*e1�ZIG d+d,� d,e
e9 �ZJG d-d.� d.e
e: �ZKdUd3d4�ZLdVd7d8�ZMdWd=d>�ZNdXdBdC�ZOdYdEdF�ZPdZdHdI�ZQd[dKdL�ZRd\dNdO�ZSd]dSdT�ZTdS )^� )� annotationsN)�
TracebackType)
�
TYPE_CHECKING�Any�Union�Generic�TypeVar�Callable�Iterator�
AsyncIterator�cast�overload)� Awaitable� ParamSpec�override�
get_origin� )�NoneType)�is_given�extract_type_arg�is_annotated_type�is_type_alias_type�extract_type_var_from_base)� BaseModel� is_basemodel�add_request_id)�RAW_RESPONSE_HEADER�OVERRIDE_CAST_TO_HEADER)�Stream� AsyncStream�is_stream_class_type�extract_stream_chunk_type)� OpenAIError�APIResponseValidationError)�FinalRequestOptions)�
BaseClient�P�R�_T�
_APIResponseTzAPIResponse[Any])�bound�_AsyncAPIResponseTzAsyncAPIResponse[Any]zlogging.Logger�logc @ s� e Zd ZU ded< ded< ded< ded< d ed
< d ed < d
ed< ded< dd�d;dd �Zed<d d ��Zed=d!d"��Zed>d#d$��Zed?d&d'��Z ed@d)d*��Z
ed@d+d,��Z edAd.d/��Z edBd0d1��Z
ed@d2d3��Zd4d5�dCd9d:�Zd4S )D�BaseAPIResponse�type[R]�_cast_to�BaseClient[Any, Any]�_clientzdict[type[Any], Any]�_parsed_by_type�bool�_is_sse_stream�1type[Stream[Any]] | type[AsyncStream[Any]] | None� _stream_clsr$ �_options�httpx.Response�
http_response�int�
retries_takenr )r; �raw�cast_to�client�stream�
stream_cls�options�return�Nonec C s4 || _ || _i | _|| _|| _|| _|| _|| _d S �N)r/ r1 r2 r4 r6 r7 r9 r; )�selfr< r= r> r? r@ rA r; � rF �;/usr/local/lib/python3.10/dist-packages/openai/_response.py�__init__= s
zBaseAPIResponse.__init__�
httpx.Headersc C � | j jS rD )r9 �headers�rE rF rF rG rK Q � zBaseAPIResponse.headers�
httpx.Requestc C rJ )zHReturns the httpx Request instance associated with the current response.)r9 �requestrL rF rF rG � http_requestU � z BaseAPIResponse.http_requestc C rJ rD )r9 � status_coderL rF rF rG rR Z rM zBaseAPIResponse.status_code� httpx.URLc C rJ )z/Returns the URL for which the request was made.)r9 �urlrL rF rF rG rT ^ rQ zBaseAPIResponse.url�strc C rJ rD )rP �methodrL rF rF rG rV c rM zBaseAPIResponse.methodc C rJ rD )r9 � http_versionrL rF rF rG rW g rM z BaseAPIResponse.http_version�datetime.timedeltac C rJ )zCThe time taken for the complete request/response cycle to complete.)r9 �elapsedrL rF rF rG rY k rQ zBaseAPIResponse.elapsedc C rJ )a Whether or not the response body has been closed.
If this is False then there is response data that has not been read yet.
You must either fully consume the response body or call `.close()`
before discarding the response to prevent resource leaks.
)r9 � is_closedrL rF rF rG rZ p s zBaseAPIResponse.is_closedc C s* d| j j� d| j� d| jj� d| j� d� S )N�<z [� z] type=�>)� __class__�__name__rR r9 �
reason_phraser/ rL rF rF rG �__repr__z s (�zBaseAPIResponse.__repr__N��torc �type[_T] | None�R | _Tc
C sH |d ur|n| j }t|�r|j}|rt|�rt|d�}t|�p |}| jrz|rGt|�s4tdt � dt
� ���t t |t
|dd�| jt t| j�d��S | jr]t t| jt
| j�| jt t| j�d��S t d| jj�}|d u rkt� �t t||| jt t| j�d��S |tu r�t td �S | j}|tkr�t t|j�S |tkr�t t|j�S |tkr�t tt|j��S |tkr�t tt|j��S |t kr�t t|j� � dk�S t � |�r�|j d kr�t t||��S |t!kr�t"d
��t � |�r�t#|t$j%�r�|t$j%kr�t&d ��t t|�S t � |��r t#|t'��s t#|t(j'��r td ��|t)u�rA|t*u�rA|t+u�rA|t,u�rAt#|t'��sAt"d
|� dt'� dt+� dt*� dt,� dt� dt� dt$j%� d���|j-�.dd��/d�^}}|dk�r�t0|��r�z|�1� }W n t2�yy } zt3�4dt5| �| � W Y d } ~ nd } ~ ww | jj6|||d�S | jj7�r�t8|d|� d�|jd��|jS |�1� }| jj6|||d�S )Nr z/Expected custom parse type to be a subclass of z or zUExpected custom stream type to be passed with a type argument, e.g. Stream[ChunkType])�failure_message)r= �responser> r5 �true�HttpxBinaryResponseContentz+Unexpected state - cast_to is `APIResponse`z:Subclasses of httpx.Response cannot be passed to `cast_to`zVPydantic models must subclass our base model type, e.g. `from openai import BaseModel`zUnsupported type, expected z to be a subclass of z, �.z content-type�*�;zapplication/jsonz5Could not read JSON from response data due to %s - %s)�datar= rg zMExpected Content-Type response header to be `application/json` but received `z
` instead.)rg �message�body)9r/ r � __value__r r r r4 r � TypeErrorr r r r( r! r9 r r1 r6 r' �_default_stream_cls�MissingStreamClassErrorr rU �text�bytes�contentr: �floatr3 �lower�inspect�isclassr_ � APIResponse� RuntimeError�
issubclass�httpx�Response�
ValueErrorr �pydantic�object�list�dictr rK �get�splitr �json� Exceptionr, �debug�type�_process_response_data�_strict_response_validationr# )
rE rc r= �originr@ rg � content_type�_rm �excrF rF rG �_parse� s�
�
��
��
��
���
�
�6�
���
� �zBaseAPIResponse._parse)r< r8 r= r. r> r0 r? r3 r@ r5 rA r$ r; r: rB rC )rB rI )rB rN )rB r: )rB rS �rB rU )rB rX )rB r3 �rc rd rB re )r_ �
__module__� __qualname__�__annotations__rH �propertyrK rP rR rT rV rW rY rZ r ra r� rF rF rF rG r- 0 s>
� r- c @ � e Zd Zed'dd��Zed(dd ��Zed)d d ��Zd d
�d*dd �Zd+dd�Zd,dd�Zd-dd�Z d.dd �Z
d/d0d d!�Z d/d1d#d$�Z d2d%d&�Z
d S )3r{ rB �
str | Nonec C � | j j�d�S �Nz x-request-id�r9 rK r� rL rF rF rG �
request_id � zAPIResponse.request_idrc �type[_T]r( c C � d S rD rF �rE rc rF rF rG �parse � zAPIResponse.parser' c C r� rD rF rL rF rF rG r� r� Nrb rd re c C s� |dur|n| j }| j�|�}|dur|S | js | �� | j|d�}t| jj�r.| j�|�}t |t
�r9t || j � || j|< t
t|�S )a� Returns the rich python representation of this response's data.
For lower-level control, see `.read()`, `.json()`, `.iter_bytes()`.
You can customise the type that the response is parsed into through
the `to` argument, e.g.
```py
from openai import BaseModel
class MyModel(BaseModel):
foo: str
obj = response.parse(to=MyModel)
print(obj.foo)
```
We support parsing:
- `BaseModel`
- `dict`
- `list`
- `Union`
- `str`
- `int`
- `float`
- `httpx.Response`
Nrb �r/ r2 r� r4 �readr� r r7 � post_parser�
isinstancer r r� r r' �rE rc � cache_key�cached�parsedrF rF rG r� s
ru c
C s0 z| j �� W S tjy } zt� |�d}~ww �z,Read and return the binary response content.N)r9 r� r~ �StreamConsumed�StreamAlreadyConsumed�rE r� rF rF rG r� M s ��zAPIResponse.readrU c C s | � � | jjS )�3Read and decode the response content into a string.�r� r9 rt rL rF rF rG rt W s zAPIResponse.textr� c C s | � � | j�� S )�*Read and decode the JSON response content.�r� r9 r� rL rF rF rG r� \ s
zAPIResponse.jsonrC c C s | j �� dS �z�Close the response and release the connection.
Automatically called if the response body is read to completion.
N)r9 �closerL rF rF rG r� a s zAPIResponse.close�
chunk_size�
int | None�Iterator[bytes]c c � � | j �|�D ]}|V qdS �z�
A byte-iterator over the decoded response content.
This automatically handles gzip, deflate and brotli encoded responses.
N)r9 �
iter_bytes�rE r� �chunkrF rF rG r� h s ��zAPIResponse.iter_bytes�
Iterator[str]c c r� �z�A str-iterator over the decoded response content
that handles both gzip, deflate, etc but also detects the content's
string encoding.
N)r9 � iter_textr� rF rF rG r� q s ��zAPIResponse.iter_textc c s � | j �� D ]}|V qdS �z;Like `iter_text()` but will only yield chunks for each lineN)r9 �
iter_lines�rE r� rF rF rG r� y s ��zAPIResponse.iter_lines�rB r� �rc r� rB r( �rB r' r� �rB ru r� �rB r� �rB rC rD )r� r� rB r� )r� r� rB r� )rB r� �r_ r� r� r� r� r
r� r� rt r� r� r� r� r� rF rF rF rG r{ s
0
r{ c @ r� )3�AsyncAPIResponserB r� c C r� r� r� rL rF rF rG r� � r� zAsyncAPIResponse.request_idrc r� r( c � � �d S rD rF r� rF rF rG r� � � �zAsyncAPIResponse.parser' c � r� rD rF rL rF rF rG r� � r� Nrb rd re c � s� �|dur|n| j }| j�|�}|dur|S | js | �� I dH | j|d�}t| jj�r2| j�|�}t |t
�r=t || j � || j|< t
t|�S )a[ Returns the rich python representation of this response's data.
For lower-level control, see `.read()`, `.json()`, `.iter_bytes()`.
You can customise the type that the response is parsed into through
the `to` argument, e.g.
```py
from openai import BaseModel
class MyModel(BaseModel):
foo: str
obj = response.parse(to=MyModel)
print(obj.foo)
```
We support parsing:
- `BaseModel`
- `dict`
- `list`
- `Union`
- `str`
- `httpx.Response`
Nrb r� r� rF rF rG r� � s �
ru c
� s8 �z | j �� I dH W S tjy } zt� |�d}~ww r� )r9 �areadr~ r� r� r� rF rF rG r� � s ���zAsyncAPIResponse.readrU c � s �| � � I dH | jjS )r� Nr� rL rF rF rG rt � s �zAsyncAPIResponse.textr� c � s �| � � I dH | j�� S )r� Nr� rL rF rF rG r� � s �
zAsyncAPIResponse.jsonrC c � s �| j �� I dH dS r� )r9 �acloserL rF rF rG r� � s �zAsyncAPIResponse.closer� r� �AsyncIterator[bytes]c C �( �| j �|�2 z 3 dH W }|V q6 dS r� )r9 � aiter_bytesr� rF rF rG r� � s ��zAsyncAPIResponse.iter_bytes�AsyncIterator[str]c C r� r� )r9 �
aiter_textr� rF rF rG r� � s ��zAsyncAPIResponse.iter_textc C s& �| j �� 2 z 3 dH W }|V q6 dS r� )r9 � aiter_linesr� rF rF rG r� � s ��zAsyncAPIResponse.iter_linesr� r� r� r� r� r� r� r� rD )r� r� rB r� )r� r� rB r� )rB r� r� rF rF rF rG r� s
.
r� c @ � e Zd ZdZd dd�ZdS )
�BinaryAPIResponse�3 Subclass of APIResponse providing helpers for dealing with binary data.
Note: If you want to stream the response data instead of eagerly reading it
all at once then you should use `.with_streaming_response` when making
the API request, e.g. `.with_streaming_response.get_binary_response()`
�file�str | os.PathLike[str]rB rC c C sJ t |dd��}| �� D ]}|�|� q W d � dS 1 s w Y dS �a^ Write the output to the given file.
Accepts a filename or any path-like object, e.g. pathlib.Path
Note: if you want to stream the data to the file instead of writing
all at once then you should use `.with_streaming_response` when making
the API request, e.g. `.with_streaming_response.get_binary_response()`
�wb��modeN��openr� �write)rE r� �frm rF rF rG �
write_to_file� s
�"�z BinaryAPIResponse.write_to_fileN�r� r� rB rC �r_ r� r� �__doc__r� rF rF rF rG r� � � r� c @ r� )
�AsyncBinaryAPIResponser� r� r� rB rC c � s� �t �|�}|jdd�I dH 4 I dH � }| �� 2 z3 dH W }|�|�I dH q6 W d �I dH dS 1 I dH s9w Y dS r� ��anyio�Pathr� r� r� )rE r� �pathr� rm rF rF rG r� s �
�.�z$AsyncBinaryAPIResponse.write_to_fileNr� r� rF rF rF rG r� r� r� c @ � e Zd Zdd�d d d
�ZdS ) �StreamedBinaryAPIResponseN�r� r� r� r� r� rB rC c C sL t |dd��}| �|�D ]}|�|� q W d � dS 1 s w Y dS �zuStreams the output to the given file.
Accepts a filename or any path-like object, e.g. pathlib.Path
r� r� Nr� )rE r� r� r� rm rF rF rG �stream_to_file s
�"�z(StreamedBinaryAPIResponse.stream_to_file�r� r� r� r� rB rC �r_ r� r� r� rF rF rF rG r� � �r� c @ r� ) � AsyncStreamedBinaryAPIResponseNr� r� r� r� r� rB rC c � s� �t �|�}|jdd�I dH 4 I dH �!}| �|�2 z3 dH W }|�|�I dH q6 W d �I dH dS 1 I dH s:w Y dS r� r� )rE r� r� r� r� rm rF rF rG r� . s �
�.�z-AsyncStreamedBinaryAPIResponse.stream_to_filer� r� rF rF rF rG r� - r� r� c s e Zd Zd� fdd� Z� ZS )rs rB rC c s t � �d� d S )NzzThe `stream` argument was set to `True` but the `stream_cls` argument was not given. See `openai._streaming` for reference��superrH rL �r^ rF rG rH ? s �z MissingStreamClassError.__init__r� )r_ r� r� rH �
__classcell__rF rF r� rG rs > s rs c s" e Zd ZdZd� fdd� Z� ZS )r� aG
Attempted to read or stream content, but the content has already
been streamed.
This can happen if you use a method like `.iter_lines()` and then attempt
to read th entire response body afterwards, e.g.
```py
response = await client.post(...)
async for line in response.iter_lines():
... # do something with `line`
content = await response.read()
# ^ error
```
If you want this behaviour you'll need to either manually accumulate the response
content or call `await response.read()` before iterating over the stream.
rB rC c s d}t � �|� d S )Na& Attempted to read or stream some content, but the content has already been streamed. This could be due to attempting to stream the response content more than once.
You can fix this by manually accumulating the response content while streaming or by calling `.read()` before starting to stream.r� )rE rn r� rF rG rH Z s � z StreamAlreadyConsumed.__init__r� )r_ r� r� r� rH r� rF rF r� rG r� E s r� c @ �. e Zd ZdZddd�Zdd d
�Zddd�ZdS )�ResponseContextManager��Context manager for ensuring that a request is not made
until it is entered and that the response will always be closed
when the context manager exits
� request_func�Callable[[], _APIResponseT]rB rC c C � || _ d | _d S rD ��
_request_func�!_ResponseContextManager__response)rE r� rF rF rG rH m �
z ResponseContextManager.__init__r) c C s | � � | _| jS rD r rL rF rF rG � __enter__q s
z ResponseContextManager.__enter__�exc_type�type[BaseException] | Noner� �BaseException | None�exc_tb�TracebackType | Nonec C s | j d ur | j �� d S d S rD )r r� �rE r r� r rF rF rG �__exit__u s
�z ResponseContextManager.__exit__N)r� r� rB rC )rB r) �r r r� r r r rB rC )r_ r� r� r� rH r r rF rF rF rG r� g �
r� c @ r� )�AsyncResponseContextManagerr� � api_request� Awaitable[_AsyncAPIResponseT]rB rC c C r� rD �� _api_request�&_AsyncResponseContextManager__response)rE r rF rF rG rH � r z$AsyncResponseContextManager.__init__r+ c � s �| j I d H | _| jS rD r rL rF rF rG �
__aenter__� s �z&AsyncResponseContextManager.__aenter__r r r� r r r c � s$ �| j d ur| j �� I d H d S d S rD )r r� r
rF rF rG � __aexit__� s �
�z%AsyncResponseContextManager.__aexit__N)r r rB rC )rB r+ r )r_ r� r� r� rH r r rF rF rF rG r r
r �func�Callable[P, R]rB �3Callable[P, ResponseContextManager[APIResponse[R]]]c � t �� �d
� fdd� �}|S ) ��Higher order function that takes one of our bound API methods and wraps it
to support streaming and returning the raw `APIResponse` object directly.
�args�P.args�kwargs�P.kwargsrB �&ResponseContextManager[APIResponse[R]]c sZ i t t|�d��p
i �}d|t< ||d< tj� g| �R i |��}tt tg tt f |��S �N�
extra_headersr? )
r r r� r � functools�partialr� r r{ r' �r r r! � make_request�r rF rG �wrapped� s
z-to_streamed_response_wrapper.<locals>.wrappedN)r r r r rB r �r" �wraps�r r' rF r& rG � to_streamed_response_wrapper� s
r+ �Callable[P, Awaitable[R]]�=Callable[P, AsyncResponseContextManager[AsyncAPIResponse[R]]]c r ) r r r r r rB �0AsyncResponseContextManager[AsyncAPIResponse[R]]c sL i t t|�d��p
i �}d|t< ||d< � | i |��}tt ttt |��S r )r r r� r r r r� r' r$ r& rF rG r' � s
z3async_to_streamed_response_wrapper.<locals>.wrappedN)r r r r rB r. r( r* rF r& rG �"async_to_streamed_response_wrapper� s
r/ �Callable[P, object]� response_cls�type[_APIResponseT]�2Callable[P, ResponseContextManager[_APIResponseT]]c � t �� �d
� �fdd� �}|S ) �' Higher order function that takes one of our bound API methods and an `APIResponse` class
and wraps the method to support streaming and returning the given response class directly.
Note: the given `response_cls` *must* be concrete, e.g. `class BinaryAPIResponse(APIResponse[bytes])`
r r r r rB �%ResponseContextManager[_APIResponseT]c s^ i t t|�d��p
i �}d|t< �|t< ||d< tj� g| �R i |��}tt tg t f |��S r )
r r r� r r r" r# r� r r) r$ �r r1 rF rG r' � s z4to_custom_streamed_response_wrapper.<locals>.wrappedN)r r r r rB r6 r( �r r1 r' rF r7 rG �#to_custom_streamed_response_wrapper� �
r9 � Callable[P, Awaitable[object]]�type[_AsyncAPIResponseT]�<Callable[P, AsyncResponseContextManager[_AsyncAPIResponseT]]c r4 ) r5 r r r r rB �/AsyncResponseContextManager[_AsyncAPIResponseT]c sP i t t|�d��p
i �}d|t< �|t< ||d< � | i |��}tt tt |��S r )r r r� r r r r r+ r$ r7 rF rG r' � s z:async_to_custom_streamed_response_wrapper.<locals>.wrappedN)r r r r rB r> r( r8 rF r7 rG �)async_to_custom_streamed_response_wrapper� r: r? �Callable[P, APIResponse[R]]c r ) ��Higher order function that takes one of our bound API methods and wraps it
to support returning the raw `APIResponse` object directly.
r r r r rB �APIResponse[R]c s@ i t t|�d��p
i �}d|t< ||d< t tt � | i |���S �Nr! r< )r r r� r r{ r' �r r r! r& rF rG r' � s z(to_raw_response_wrapper.<locals>.wrappedN)r r r r rB rB r( r* rF r& rG �to_raw_response_wrapper� � rE �+Callable[P, Awaitable[AsyncAPIResponse[R]]]c r ) rA r r r r rB �AsyncAPIResponse[R]c � sH �i t t|�d��p i �}d|t< ||d< t tt � | i |��I d H �S rC )r r r� r r� r' rD r& rF rG r' s
� z.async_to_raw_response_wrapper.<locals>.wrappedN)r r r r rB rH r( r* rF r& rG � async_to_raw_response_wrapper rF rI �Callable[P, _APIResponseT]c r4 ) � Higher order function that takes one of our bound API methods and an `APIResponse` class
and wraps the method to support returning the given response class directly.
Note: the given `response_cls` *must* be concrete, e.g. `class BinaryAPIResponse(APIResponse[bytes])`
r r r r rB r) c sD i t t|�d��p
i �}d|t< �|t< ||d< t t� | i |���S rC )r r r� r r r) rD r7 rF rG r' s
z/to_custom_raw_response_wrapper.<locals>.wrappedN)r r r r rB r) r( r8 rF r7 rG � to_custom_raw_response_wrapper �
rL �*Callable[P, Awaitable[_AsyncAPIResponseT]]c r4 ) rK r r r r rB r c sH i t t|�d��p
i �}d|t< �|t< ||d< t tt � | i |���S rC )r r r� r r r r+ rD r7 rF rG r' 4 s
z5async_to_custom_raw_response_wrapper.<locals>.wrappedN)r r r r rB r r( r8 rF r7 rG �$async_to_custom_raw_response_wrapper* rM rO �typ�type[BaseAPIResponse[Any]]r� c C s t | tdtttf�dd�S )a Given a type like `APIResponse[T]`, returns the generic type variable `T`.
This also handles the case where a concrete subclass is given, e.g.
```py
class MyResponse(APIResponse[bytes]):
...
extract_response_type(MyResponse) -> bytes
```
ztuple[type, ...]r )�
generic_bases�index)r r r- r{ r� )rP rF rF rG �extract_response_typeA s
�rT )r r rB r )r r, rB r- )r r0 r1 r2 rB r3 )r r; r1 r< rB r= )r r rB r@ )r r, rB rG )r r0 r1 r2 rB rJ )r r; r1 r< rB rN )rP rQ rB r� )U�
__future__r �osry �logging�datetimer" �typesr �typingr r r r r r r
r r r
�typing_extensionsr r r r r� r~ r� �_typesr �_utilsr r r r r �_modelsr r r �
_constantsr r �
_streamingr r r r! � _exceptionsr" r# r$ � _base_clientr% r& r' r( r) r+ � getLoggerr_ r, r� r- r{ r� ru r� r� r� r� rq rs r� r� r r+ r/ r9 r? rE rI rL rO rT rF rF rF rG �<module> s` 0 cmk"