a ~go@sddlmZddlmZmZmZmZmZmZm Z ddl m Z ddl m Z ddlZddlmZddlmZmZmZmZmZdd lmZmZdd lmZdd lmZmZdd lm Z m!Z!dd l"m#Z#ddl$m%Z%m&Z&ddl'm(Z(ddl)m*Z*m+Z,m-Z.m/Z0ddl1m2Z2ddl3m4Z4m5Z5ddl6m7Z7ddl8m9Z9ddl:m;Z;ddlm?Z?ddl@mAZAddlBmCZCddlDmEZEddlFmGZGddlHmIZIddlJmKZKddgZLGd ddeZMGd!ddeZNGd"d#d#ZOGd$d%d%ZPGd&d'd'ZQGd(d)d)ZRdS)*) annotations)DictListTypeUnionIterableOptionalcast)partial)LiteralN)_legacy_response) NOT_GIVENBodyQueryHeadersNotGiven)maybe_transformasync_maybe_transform)cached_property)SyncAPIResourceAsyncAPIResource)to_streamed_response_wrapper"async_to_streamed_response_wrapper)Stream)ChatCompletionReasoningEffortcompletion_create_params)make_request_options)ResponseFormatTvalidate_input_toolsparse_chat_completiontype_to_response_format_param) ChatModel)ChatCompletionStreamManager AsyncChatCompletionStreamManager)Metadata)ChatCompletion)ChatCompletionChunk)ParsedChatCompletion)ChatCompletionModality)ChatCompletionToolParam)ChatCompletionAudioParam)ChatCompletionMessageParam) ChatCompletionStreamOptionsParam)$ChatCompletionPredictionContentParam)#ChatCompletionToolChoiceOptionParam CompletionsAsyncCompletionsc$@sTeZdZeddddZeddddZeeeeeeeeeeeeeeeeeeeeeeeeeeeddded d d d d ddddddddddddddddddddddddddd d!d"d#d$"d%d&Zeeeeeeeeeeeeeeeeeeeeeeeeeeeddded d d d d'ddddddddddddddddddddddddddd d!d"d(d$"d)d*ZdS)+r0CompletionsWithRawResponsereturncCst|Sa This property can be used as a prefix for any HTTP method call to return the the raw response object instead of the parsed content. For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers )r2selfr8k/var/www/html/emsaiapi.evdpl.com/venv/lib/python3.9/site-packages/openai/resources/beta/chat/completions.pywith_raw_response/szCompletions.with_raw_response CompletionsWithStreamingResponsecCst|Sz An alternative to `.with_raw_response` that doesn't eagerly read the response body. For more information, see https://www.github.com/openai/openai-python#with_streaming_response )r;r6r8r8r9with_streaming_response9sz#Completions.with_streaming_responseNaudioresponse_formatfrequency_penalty function_call functions logit_biaslogprobsmax_completion_tokens max_tokensmetadata modalitiesnparallel_tool_calls predictionpresence_penaltyreasoning_effortseed service_tierstopstorestream_options temperature tool_choicetools top_logprobstop_puser extra_headers extra_query extra_bodytimeout$Iterable[ChatCompletionMessageParam]Union[str, ChatModel]-Optional[ChatCompletionAudioParam] | NotGiven type[ResponseFormatT] | NotGivenOptional[float] | NotGiven0completion_create_params.FunctionCall | NotGiven6Iterable[completion_create_params.Function] | NotGiven#Optional[Dict[str, int]] | NotGivenOptional[bool] | NotGivenOptional[int] | NotGivenOptional[Metadata] | NotGiven1Optional[List[ChatCompletionModality]] | NotGivenbool | NotGiven9Optional[ChatCompletionPredictionContentParam] | NotGiven2Optional[ChatCompletionReasoningEffort] | NotGiven/Optional[Literal['auto', 'default']] | NotGiven*Union[Optional[str], List[str]] | NotGiven5Optional[ChatCompletionStreamOptionsParam] | NotGiven.ChatCompletionToolChoiceOptionParam | NotGiven,Iterable[ChatCompletionToolParam] | NotGivenstr | NotGivenHeaders | None Query | None Body | None'float | httpx.Timeout | None | NotGiven%ParsedChatCompletion[ResponseFormatT]"messagesmodelr?r@rArBrCrDrErFrGrHrIrJrKrLrMrNrOrPrQrRrSrTrUrVrWrXrYrZr[r\r]r4c!#"stddi|pi}dddfdd }"|jdt|||||||| | | | | |||||t||||d ||||||d tjt||| |!|"d ttt t t d d S) aWrapper over the `client.chat.completions.create()` method that provides richer integrations with Python specific types & returns a `ParsedChatCompletion` object, which is a subclass of the standard `ChatCompletion` class. You can pass a pydantic model to this method and it will automatically convert the model into a JSON schema, send it to the API and parse the response content back into the given model. This method will also automatically parse `function` tool calls if: - You use the `openai.pydantic_function_tool()` helper method - You mark your tool schema with `"strict": True` Example usage: ```py from pydantic import BaseModel from openai import OpenAI class Step(BaseModel): explanation: str output: str class MathResponse(BaseModel): steps: List[Step] final_answer: str client = OpenAI() completion = client.beta.chat.completions.parse( model="gpt-4o-2024-08-06", messages=[ {"role": "system", "content": "You are a helpful math tutor."}, {"role": "user", "content": "solve 8x + 31 = 2"}, ], response_format=MathResponse, ) message = completion.choices[0].message if message.parsed: print(message.parsed.steps) print("answer: ", message.parsed.final_answer) ``` X-Stainless-Helper-Methodbeta.chat.completions.parser&rwraw_completionr4cst|dSN)r@chat_completion input_tools_parse_chat_completionr~r@rVr8r9parsers z!Completions.parse..parser/chat/completionsF)ryrzr?rArBrCrDrErFrGrHrIrJrKrLrMrNr@rOrPrQrRstreamrSrTrUrVrWrXrYrZr[r\r] post_parserbodyoptionsZcast_tor) _validate_input_tools_postr_type_to_response_formatrCompletionCreateParamsrr rr(rr&#r7ryrzr?r@rArBrCrDrErFrGrHrIrJrKrLrMrNrOrPrQrRrSrTrUrVrWrXrYrZr[r\r]rr8rr9parseBshQ # zCompletions.parseJcompletion_create_params.ResponseFormat | type[ResponseFormatT] | NotGivenz,ChatCompletionStreamManager[ResponseFormatT]c!#%Csxddi|p i}t|jjjj|||dt|||||| | | | | ||||||||||||||||||| |!d#}"t|"||dS)aWrapper over the `client.chat.completions.create(stream=True)` method that provides a more granular event API and automatic accumulation of each delta. This also supports all of the parsing utilities that `.parse()` does. Unlike `.create(stream=True)`, the `.stream()` method requires usage within a context manager to prevent accidental leakage of the response: ```py with client.beta.chat.completions.stream( model="gpt-4o-2024-08-06", messages=[...], ) as stream: for event in stream: if event.type == "content.delta": print(event.delta, flush=True, end="") ``` When the context manager is entered, a `ChatCompletionStream` instance is returned which, like `.create(stream=True)` is an iterator. The full list of events that are yielded by the iterator are outlined in [these docs](https://github.com/openai/openai-python/blob/main/helpers.md#chat-completions-events). When the context manager exits, the response will be closed, however the `stream` instance is still available outside the context manager. r{beta.chat.completions.streamT)"ryrzr?rr@rArBrCrDrErFrGrHrIrJrKrLrMrNrOrPrRrQrSrTrUrVrWrXrYrZr[r\r]r@r)r _clientchat completionscreaterr##r7ryrzr?r@rArBrCrDrErFrGrHrIrJrKrLrMrNrOrPrQrRrSrTrUrVrWrXrYrZr[r\r]Z api_requestr8r8r9rs\> %zCompletions.stream __name__ __module__ __qualname__rr:r=rrrr8r8r8r9r0.s  Tc$@sTeZdZeddddZeddddZeeeeeeeeeeeeeeeeeeeeeeeeeeeddded d d d d ddddddddddddddddddddddddddd d!d"d#d$"d%d&Zeeeeeeeeeeeeeeeeeeeeeeeeeeeddded d d d d'ddddddddddddddddddddddddddd d!d"d(d$"d)d*ZdS)+r1AsyncCompletionsWithRawResponser3cCst|Sr5)rr6r8r8r9r:Bsz"AsyncCompletions.with_raw_response%AsyncCompletionsWithStreamingResponsecCst|Sr<)rr6r8r8r9r=Lsz(AsyncCompletions.with_streaming_responseNr>r^r_r`rarbrcrdrerfrgrhrirjrkrlrmrnrorprqrrrsrtrurvrwrxc!#"stddi|pi}dddfdd }"|jdt|||||||| | | | | |||||t||||d ||||||d tjId Ht||| |!|"d ttt t t d d Id HS)aWrapper over the `client.chat.completions.create()` method that provides richer integrations with Python specific types & returns a `ParsedChatCompletion` object, which is a subclass of the standard `ChatCompletion` class. You can pass a pydantic model to this method and it will automatically convert the model into a JSON schema, send it to the API and parse the response content back into the given model. This method will also automatically parse `function` tool calls if: - You use the `openai.pydantic_function_tool()` helper method - You mark your tool schema with `"strict": True` Example usage: ```py from pydantic import BaseModel from openai import AsyncOpenAI class Step(BaseModel): explanation: str output: str class MathResponse(BaseModel): steps: List[Step] final_answer: str client = AsyncOpenAI() completion = await client.beta.chat.completions.parse( model="gpt-4o-2024-08-06", messages=[ {"role": "system", "content": "You are a helpful math tutor."}, {"role": "user", "content": "solve 8x + 31 = 2"}, ], response_format=MathResponse, ) message = completion.choices[0].message if message.parsed: print(message.parsed.steps) print("answer: ", message.parsed.final_answer) ``` r{r|r&rwr}cst|dSrrrrr8r9rs z&AsyncCompletions.parse..parserrF)ryrzr?rArBrCrDrErFrGrHrIrJrKrLrMrNr@rOrPrRrQrrSrTrUrVrWrXrYNrr) rrrrrrrr rr(rr&rr8rr9rUshQ # zAsyncCompletions.parserz1AsyncChatCompletionStreamManager[ResponseFormatT]c!#$Cs~t|ddi|pi}|jjjj|||dt|||||| | | | | ||||||||||||||||||| |!d"}"t|"||dS)aWrapper over the `client.chat.completions.create(stream=True)` method that provides a more granular event API and automatic accumulation of each delta. This also supports all of the parsing utilities that `.parse()` does. Unlike `.create(stream=True)`, the `.stream()` method requires usage within a context manager to prevent accidental leakage of the response: ```py async with client.beta.chat.completions.stream( model="gpt-4o-2024-08-06", messages=[...], ) as stream: async for event in stream: if event.type == "content.delta": print(event.delta, flush=True, end="") ``` When the context manager is entered, an `AsyncChatCompletionStream` instance is returned which, like `.create(stream=True)` is an async iterator. The full list of events that are yielded by the iterator are outlined in [these docs](https://github.com/openai/openai-python/blob/main/helpers.md#chat-completions-events). When the context manager exits, the response will be closed, however the `stream` instance is still available outside the context manager. r{rT)"ryrzr?rr@rArBrCrDrErFrGrHrIrJrKrLrMrNrOrPrQrRrSrTrUrVrWrXrYrZr[r\r]r)rrrrrrr$rr8r8r9rs\= $zAsyncCompletions.streamrr8r8r8r9r1As  Tc@seZdZdddddZdS)r2r0Nonerr4cCs||_t|j|_dSN) _completionsr Zto_raw_response_wrapperrr7rr8r8r9__init__Vsz#CompletionsWithRawResponse.__init__Nrrrrr8r8r8r9r2Usr2c@seZdZdddddZdS)rr1rrcCs||_t|j|_dSr)rr Zasync_to_raw_response_wrapperrrr8r8r9r_sz(AsyncCompletionsWithRawResponse.__init__Nrr8r8r8r9r^src@seZdZdddddZdS)r;r0rrcCs||_t|j|_dSr)rrrrr8r8r9rhsz)CompletionsWithStreamingResponse.__init__Nrr8r8r8r9r;gsr;c@seZdZdddddZdS)rr1rrcCs||_t|j|_dSr)rrrrr8r8r9rqsz.AsyncCompletionsWithStreamingResponse.__init__Nrr8r8r8r9rpsr)S __future__rtypingrrrrrrr functoolsr typing_extensionsr httpxr _typesrrrrr_utilsrr_compatr _resourcerr _responserr _streamingrZ types.chatrr _base_clientrZ lib._parsingrrrr rr!rZtypes.chat_modelr"Zlib.streaming.chatr#r$Ztypes.shared_paramsr%Ztypes.chat.chat_completionr&Z types.chat.chat_completion_chunkr'Z!types.chat.parsed_chat_completionr(Z#types.chat.chat_completion_modalityr)Z%types.chat.chat_completion_tool_paramr*Z&types.chat.chat_completion_audio_paramr+Z(types.chat.chat_completion_message_paramr,Z/types.chat.chat_completion_stream_options_paramr-Z3types.chat.chat_completion_prediction_content_paramr.Z3types.chat.chat_completion_tool_choice_option_paramr/__all__r0r1r2rr;rr8r8r8r9sL $