o hip@sUddlmZddlZddlZddlZddlZddlZddlmZddl m Z m Z m Z m Z mZmZmZmZmZmZddlmZmZmZmZddlZddlZddlZddlmZddlmZm Z m!Z!m"Z"m#Z#dd l$m%Z%m&Z&dd l'm(Z(m)Z)dd l*m+Z+m,Z,m-Z-m.Z.dd l/m0Z0m1Z1e rdd l$m2Z2ddl3m4Z4edZ5edZ6edZ7edddZ8edddZ9e:e;ZGddde>e6Z?Gddde>e6Z@Gdd d e?eAZBGd!d"d"e@eAZCGd#d$d$e?eAZDGd%d&d&e@eAZEGd'd(d(eFZGGd)d*d*e0ZHGd+d,d,e e8ZIGd-d.d.e e9ZJdUd3d4ZKdVd7d8ZLdWd=d>ZMdXdBdCZNdYdEdFZOdZdHdIZPd[dKdLZQd\dNdOZRd]dSdTZSdS)^) annotationsN) TracebackType) TYPE_CHECKINGAnyUnionGenericTypeVarCallableIterator AsyncIteratorcastoverload) Awaitable ParamSpecoverride get_origin)NoneType)is_givenextract_type_argis_annotated_typeis_type_alias_typeextract_type_var_from_base) BaseModel is_basemodel)RAW_RESPONSE_HEADEROVERRIDE_CAST_TO_HEADER)Stream AsyncStreamis_stream_class_typeextract_stream_chunk_type) GroqErrorAPIResponseValidationError)FinalRequestOptions) BaseClientPR_T _APIResponseTzAPIResponse[Any])bound_AsyncAPIResponseTzAsyncAPIResponse[Any]zlogging.Loggerlogc@seZdZUded<ded<ded<ded<d ed <d ed <d ed<ded< ddd;ddZedd#d$Zed?d&d'Z ed@d)d*Z ed@d+d,Z edAd.d/Z edBd0d1Z ed@d2d3Zd4d5dCd9d:Zd4S)DBaseAPIResponsetype[R]_cast_toBaseClient[Any, Any]_clientzdict[type[Any], Any]_parsed_by_typebool_is_sse_stream1type[Stream[Any]] | type[AsyncStream[Any]] | None _stream_clsr#_optionshttpx.Response http_responseint retries_takenr)r:rawcast_toclientstream stream_clsoptionsreturnNonecCs4||_||_i|_||_||_||_||_||_dSN)r.r0r1r3r5r6r8r:)selfr;r<r=r>r?r@r:rEb/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/groq/_response.py__init__=s  zBaseAPIResponse.__init__ httpx.HeaderscC|jjSrC)r8headersrDrErErFrJQzBaseAPIResponse.headers httpx.RequestcCrI)zHReturns the httpx Request instance associated with the current response.)r8requestrKrErErF http_requestUzBaseAPIResponse.http_requestcCrIrC)r8 status_coderKrErErFrQZrLzBaseAPIResponse.status_code httpx.URLcCrI)z/Returns the URL for which the request was made.)r8urlrKrErErFrS^rPzBaseAPIResponse.urlstrcCrIrC)rOmethodrKrErErFrUcrLzBaseAPIResponse.methodcCrIrC)r8 http_versionrKrErErFrVgrLzBaseAPIResponse.http_versiondatetime.timedeltacCrI)zCThe time taken for the complete request/response cycle to complete.)r8elapsedrKrErErFrXkrPzBaseAPIResponse.elapsedcCrI)aWhether 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. )r8 is_closedrKrErErFrYpszBaseAPIResponse.is_closedc Cs*d|jjd|jd|jjd|jd S)N) __class____name__rQr8 reason_phraser.rKrErErF__repr__zs(zBaseAPIResponse.__repr__Ntorbtype[_T] | NoneR | _Tc Cs |dur|n|j}t|r|j}|rt|rt|d}t|p |}|jrz|rGt|s4tdt dt t t |t |dd|jt t|jdS|jr]t t|jt |j|jt t|jdSt d|jj}|durktt t|||jt t|jdS|turt tdS|j}|tkrt t|jS|tkrt t|jS|tkrt tt|jS|tkrt tt|jS|tkrt t|jdkS|tkrtd t !|rt"|t#j$r|t#j$krt%d t t|St !|rt"|t&st"|t'j&rtd |t(ur-|t)ur-|t*ur-|t+ur-t"|t&s-td |d t&dt*dt)dt+dtdtdt#j$d|j,-dd.d^}}|dkrt/|roz|0}Wnt1ye} zt23dt4| | WYd} ~ nd} ~ ww|jj5|||dS|jj6rt7|d|d|jd|jS|0}|jj5|||dS)Nrz/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=r4truez+Unexpected state - cast_to is `APIResponse`z:Subclasses of httpx.Response cannot be passed to `cast_to`zTPydantic models must subclass our base model type, e.g. `from groq 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<rfzMExpected Content-Type response header to be `application/json` but received `z ` instead.)rfmessagebody)8r.r __value__rrrr3r TypeErrorrrr r'r r8rr0r5r&_default_stream_clsMissingStreamClassErrorrrTtextbytescontentr9floatr2lower APIResponse RuntimeErrorinspectisclass issubclasshttpxResponse ValueErrorrpydanticobjectlistdictrrJgetsplitrjson Exceptionr+debugtype_process_response_data_strict_response_validationr") rDrbr<originr?rf content_type_rkexcrErErF_parses                  6      zBaseAPIResponse._parse)r;r7r<r-r=r/r>r2r?r4r@r#r:r9rArB)rArH)rArM)rAr9)rArRrArT)rArW)rAr2rbrcrArd)r^ __module__ __qualname____annotations__rGpropertyrJrOrQrSrUrVrXrYrr`rrErErErFr,0s>           r,c@eZdZed$ddZed%ddZd d d&d dZd'ddZd(ddZd)ddZd*ddZd+d,ddZ d+d-d d!Z d.d"d#Z d S)/rwrbtype[_T]rAr'cCdSrCrErDrbrErErFparsezAPIResponse.parser&cCrrCrErKrErErFrrNrarcrdcCsj|dur|n|j}|j|}|dur|S|js||j|d}t|jjr.|j|}||j|<|S)aReturns 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 groq 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` Nra r.r1rr3readrrr6 post_parserrDrb cache_keycachedparsedrErErFrs     rsc Cs0z|jWStjy}zt|d}~wwz,Read and return the binary response content.N)r8rr|StreamConsumedStreamAlreadyConsumedrDrrErErFrBs  zAPIResponse.readrTcCs||jjS)3Read and decode the response content into a string.rr8rrrKrErErFrrLszAPIResponse.textrcCs||jS)*Read and decode the JSON response content.rr8rrKrErErFrQs zAPIResponse.jsonrBcCs|jdSzClose the response and release the connection. Automatically called if the response body is read to completion. N)r8closerKrErErFrVszAPIResponse.close chunk_size int | NoneIterator[bytes]cc|j|D]}|VqdSz A byte-iterator over the decoded response content. This automatically handles gzip, deflate and brotli encoded responses. N)r8 iter_bytesrDrchunkrErErFr]szAPIResponse.iter_bytes Iterator[str]ccrzA str-iterator over the decoded response content that handles both gzip, deflate, etc but also detects the content's string encoding. N)r8 iter_textrrErErFrfszAPIResponse.iter_textccs|jD]}|VqdSz;Like `iter_text()` but will only yield chunks for each lineN)r8 iter_linesrDrrErErFrnszAPIResponse.iter_linesrbrrAr'rAr&rrArsrrArrArBrC)rrrAr)rrrAr)rAr r^rrr rrrrrrrrrrErErErFrws   -    rwc@r)/AsyncAPIResponserbrrAr'cdSrCrErrErErFruzAsyncAPIResponse.parser&crrCrErKrErErFrxrNrarcrdcsr|dur|n|j}|j|}|dur|S|js |IdH|j|d}t|jjr2|j|}||j|<|S)aYReturns 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 groq 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` NrarrrErErFr{s     rsc s8z |jIdHWStjy}zt|d}~wwr)r8areadr|rrrrErErFrszAsyncAPIResponse.readrTcs|IdH|jjS)rNrrKrErErFrrszAsyncAPIResponse.textrcs|IdH|jS)rNrrKrErErFrs zAsyncAPIResponse.jsonrBcs|jIdHdSr)r8acloserKrErErFrszAsyncAPIResponse.closerrAsyncIterator[bytes]cC(|j|2z 3dHW}|Vq6dSr)r8 aiter_bytesrrErErFrszAsyncAPIResponse.iter_bytesAsyncIterator[str]cCrr)r8 aiter_textrrErErFrszAsyncAPIResponse.iter_textcCs&|j2z 3dHW}|Vq6dSr)r8 aiter_linesrrErErFrszAsyncAPIResponse.iter_linesrrrrrrrrC)rrrAr)rrrAr)rArrrErErErFrts   +    rc@eZdZdZd ddZdS) BinaryAPIResponse3Subclass 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()` filestr | os.PathLike[str]rArBcCsJt|dd}|D]}||q WddS1swYdSa^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()` wbmodeNopenrwrite)rDrfrkrErErF write_to_files   "zBinaryAPIResponse.write_to_fileNrrrArBr^rr__doc__rrErErErFrrc@r) AsyncBinaryAPIResponserrrrArBc st|}|jddIdH4IdH }|2z3dHW}||IdHq6WdIdHdS1IdHs9wYdSranyioPathrrr)rDrpathrrkrErErFrs .z$AsyncBinaryAPIResponse.write_to_fileNrrrErErErFrrrc@eZdZddd d d ZdS) StreamedBinaryAPIResponseNrrrrrrArBcCsLt|dd}||D]}||q WddS1swYdSzuStreams the output to the given file. Accepts a filename or any path-like object, e.g. pathlib.Path rrNr)rDrrrrkrErErFstream_to_file s   "z(StreamedBinaryAPIResponse.stream_to_filerrrrrArBr^rrrrErErErFr rc@r) AsyncStreamedBinaryAPIResponseNrrrrrrArBc st|}|jddIdH4IdH!}||2z3dHW}||IdHq6WdIdHdS1IdHs:wYdSrr)rDrrrrrkrErErFrs .z-AsyncStreamedBinaryAPIResponse.stream_to_filerrrErErErFrrrcseZdZdfdd ZZS)rqrArBcstddS)NzxThe `stream` argument was set to `True` but the `stream_cls` argument was not given. See `groq._streaming` for referencesuperrGrKr]rErFrG-sz MissingStreamClassError.__init__r)r^rrrG __classcell__rErErrFrq,srqcs"eZdZdZdfdd ZZS)raG 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. rArBcsd}t|dS)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)rDrlrrErFrGHs zStreamAlreadyConsumed.__init__r)r^rrrrGrrErErrFr3src@.eZdZdZdddZdd d ZdddZdS)ResponseContextManagerContext 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_funcCallable[[], _APIResponseT]rArBcC||_d|_dSrC _request_func!_ResponseContextManager__response)rDrrErErFrG[ zResponseContextManager.__init__r(cCs||_|jSrCrrKrErErF __enter___s z ResponseContextManager.__enter__exc_typetype[BaseException] | NonerBaseException | Noneexc_tbTracebackType | NonecCs|jdur |jdSdSrC)rrrDrrrrErErF__exit__cs zResponseContextManager.__exit__N)rrrArB)rAr(rrrrrrrArB)r^rrrrGrrrErErErFrU   rc@r)AsyncResponseContextManagerr api_requestAwaitable[_AsyncAPIResponseT]rArBcCrrC _api_request&_AsyncResponseContextManager__response)rDrrErErFrGsrz$AsyncResponseContextManager.__init__r*cs|jIdH|_|jSrCrrKrErErF __aenter__wsz&AsyncResponseContextManager.__aenter__rrrrrrcs$|jdur|jIdHdSdSrC)r rrrErErF __aexit__{s z%AsyncResponseContextManager.__aexit__N)rrrArB)rAr*r)r^rrrrGr r rErErErFrmrrfuncCallable[P, R]rA3Callable[P, ResponseContextManager[APIResponse[R]]]ctd 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. argsP.argskwargsP.kwargsrA&ResponseContextManager[APIResponse[R]]csZitt|dp i}d|t<||d<tjg|Ri|}tttgtt f|SN extra_headersr>) r rrr functoolspartialrr rwr&rrr make_requestr rErFwrappeds z-to_streamed_response_wrapper..wrappedN)rrrrrArrwrapsr rrErrFto_streamed_response_wrappers r!Callable[P, Awaitable[R]]=Callable[P, AsyncResponseContextManager[AsyncAPIResponse[R]]]cr) rrrrrrA0AsyncResponseContextManager[AsyncAPIResponse[R]]csLitt|dp i}d|t<||d<|i|}ttttt|Sr)r rrrrrrr&rrrErFrs z3async_to_streamed_response_wrapper..wrappedN)rrrrrAr$rr rErrF"async_to_streamed_response_wrappers r%Callable[P, object] response_clstype[_APIResponseT]2Callable[P, ResponseContextManager[_APIResponseT]]ctd 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])` rrrrrA%ResponseContextManager[_APIResponseT]cs^itt|dp i}d|t<|t<||d<tjg|Ri|}tttgt f|Sr) r rrrrrrrr r(rr r'rErFrs z4to_custom_streamed_response_wrapper..wrappedN)rrrrrAr,rr r'rrEr-rF#to_custom_streamed_response_wrapper  r/Callable[P, Awaitable[object]]type[_AsyncAPIResponseT].wrappedN)rrrrrAr4rr.rEr-rF)async_to_custom_streamed_response_wrapperr0r5Callable[P, APIResponse[R]]cr) Higher order function that takes one of our bound API methods and wraps it to support returning the raw `APIResponse` object directly. rrrrrAAPIResponse[R]cs@itt|dp i}d|t<||d<ttt|i|SNrr;)r rrrrwr&rrrrrErFrsz(to_raw_response_wrapper..wrappedN)rrrrrAr8rr rErrFto_raw_response_wrapperr;+Callable[P, Awaitable[AsyncAPIResponse[R]]]cr) r7rrrrrAAsyncAPIResponse[R]csHitt|dp i}d|t<||d<ttt|i|IdHSr9)r rrrrr&r:rrErFrs z.async_to_raw_response_wrapper..wrappedN)rrrrrAr>rr rErrFasync_to_raw_response_wrapperr<r?Callable[P, _APIResponseT]cr*) 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])` rrrrrAr(csDitt|dp i}d|t<|t<||d<tt|i|Sr9)r rrrrr(r:r-rErFr s z/to_custom_raw_response_wrapper..wrappedN)rrrrrAr(rr.rEr-rFto_custom_raw_response_wrapper  rB*Callable[P, Awaitable[_AsyncAPIResponseT]]cr*) rArrrrrArcsHitt|dp i}d|t<|t<||d<ttt|i|Sr9)r rrrrrr*r:r-rErFr"s z5async_to_custom_raw_response_wrapper..wrappedN)rrrrrArrr.rEr-rF$async_to_custom_raw_response_wrapperrCrEtyptype[BaseAPIResponse[Any]]rcCst|tdtttfddS)aGiven 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_basesindex)rr r,rwr)rFrErErFextract_response_type/s  rJ)r r rAr)r r"rAr#)r r&r'r(rAr))r r1r'r2rAr3)r r rAr6)r r"rAr=)r r&r'r(rAr@)r r1r'r2rArD)rFrGrAr)T __future__rosryloggingdatetimertypesrtypingrrrrrr r r r r typing_extensionsrrrrrr|r_typesr_utilsrrrrr_modelsrr _constantsrr _streamingrrrr _exceptionsr!r"r# _base_clientr$r%r&r'r(r* getLoggerr^r+rr,rwrrsrrrrrorqrrrr!r%r/r5r;r?rBrErJrErErErFs` 0      _fd"