U ܟjq@sddlmZddlmZmZmZmZmZmZm Z ddl m Z ddl m Z ddlZddlmZddlmZmZmZmZmZdd lmZmZdd lmZdd lmZmZdd lm Z m!Z!dd l"m#Z#ddl$m%Z%ddl&m'Z'ddl(m)Z)m*Z+m,Z-m.Z/ddl0m1Z1ddl2m3Z3m4Z4ddl5m6Z6m7Z7ddl8m9Z9ddl:m;Z;ddlm?Z?ddl@mAZAddlBmCZCddlDmEZEddlFmGZGddlHmIZIddgZJGdddeZKGd ddeZLGd!d"d"ZMGd#d$d$ZNGd%d&d&ZOGd'd(d(ZPdS))) 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)completion_create_params)make_request_options)ResponseFormatTvalidate_input_toolsparse_chat_completiontype_to_response_format_param) ChatModel)ChatCompletionStreamManager AsyncChatCompletionStreamManager)MetadataReasoningEffort)ChatCompletion)ChatCompletionChunk)ParsedChatCompletion)ChatCompletionToolParam)ChatCompletionAudioParam)ChatCompletionMessageParam) ChatCompletionStreamOptionsParam)$ChatCompletionPredictionContentParam)#ChatCompletionToolChoiceOptionParam CompletionsAsyncCompletionsc%@s\eZdZeddddZeddddZeeeeeeeeeeeeeeeeeeeeeeeeeeeeddded d d d d ddddddddddddddddddddddddddd d!d"d#d$d%#d&d'Zeeeeeeeeeeeeeeeeeeeeeeeeeeeeddded d d d d(ddddddddddddddddddddddddddd d!d"d#d)d%#d*d+ZdS),r/CompletionsWithRawResponsereturncCst|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 )r1selfr7J/tmp/pip-unpacked-wheel-2qj3ofc_/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:r5r7r7r8with_streaming_response5sz#Completions.with_streaming_responseN audioresponse_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_puserweb_search_options 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] | NotGiven5Optional[List[Literal[('text', 'audio')]]] | NotGivenbool | NotGiven9Optional[ChatCompletionPredictionContentParam] | NotGiven$Optional[ReasoningEffort] | NotGiven1Optional[Literal[('auto', 'default')]] | NotGiven0Union[Optional[str], List[str], None] | NotGiven5Optional[ChatCompletionStreamOptionsParam] | NotGiven.ChatCompletionToolChoiceOptionParam | NotGiven,Iterable[ChatCompletionToolParam] | NotGivenstr | NotGiven4completion_create_params.WebSearchOptions | NotGivenHeaders | None Query | None Body | None'float | httpx.Timeout | None | NotGiven%ParsedChatCompletion[ResponseFormatT]#messagesmodelr>r?r@rArBrCrDrErFrGrHrIrJrKrLrMrNrOrPrQrRrSrTrUrVrWrXrYrZr[r\r]r3c"$#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&rxraw_completionr3cst|dSN)r?Zchat_completion input_tools_parse_chat_completionrr?rUr7r8parsers z!Completions.parse..parser/chat/completionsF)rzr{r>r@rArBrCrDrErFrGrHrIrJrKrLrMr?rNrOrPrQstreamrRrSrTrUrVrWrXrYrZr[r\r]Z post_parserbodyoptionsZcast_tor) _validate_input_tools_postr_type_to_response_formatrCompletionCreateParamsrr rr(rr&$r6rzr{r>r?r@rArBrCrDrErFrGrHrIrJrKrLrMrNrOrPrQrRrSrTrUrVrWrXrYrZr[r\r]rr7rr8parse>slR!$ zCompletions.parseJcompletion_create_params.ResponseFormat | type[ResponseFormatT] | NotGivenz,ChatCompletionStreamManager[ResponseFormatT]c"$&Cszddi|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)#rzr{r>rr?r@rArBrCrDrErFrGrHrIrJrKrLrMrNrOrQrPrRrSrTrUrVrWrXrYrZr[r\r]r?r)r _clientchat completionscreaterr"$r6rzr{r>r?r@rArBrCrDrErFrGrHrIrJrKrLrMrNrOrPrQrRrSrTrUrVrWrXrYrZr[r\r]Z api_requestr7r7r8rs`? &zCompletions.stream __name__ __module__ __qualname__rr9r<rrrr7r7r7r8r/*s  Vc%@s\eZdZeddddZeddddZeeeeeeeeeeeeeeeeeeeeeeeeeeeeddded d d d d ddddddddddddddddddddddddddd d!d"d#d$d%#d&d'Zeeeeeeeeeeeeeeeeeeeeeeeeeeeeddded d d d d(ddddddddddddddddddddddddddd d!d"d#d)d%#d*d+ZdS),r0AsyncCompletionsWithRawResponser2cCst|Sr4)rr5r7r7r8r9Bsz"AsyncCompletions.with_raw_response%AsyncCompletionsWithStreamingResponsecCst|Sr;)rr5r7r7r8r<Lsz(AsyncCompletions.with_streaming_responseNr=r^r_r`rarbrcrdrerfrgrhrirjrkrlrmrnrorprqrrrsrtrurvrwrxryc"$#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&rxr~cst|dSrrrrr7r8rs z&AsyncCompletions.parse..parserrF)rzr{r>r@rArBrCrDrErFrGrHrIrJrKrLrMr?rNrOrQrPrrRrSrTrUrVrWrXrYNrr) rrrrrrrr rr(rr&rr7rr8rUslR!$ zAsyncCompletions.parserz1AsyncChatCompletionStreamManager[ResponseFormatT]c"$%Cst|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)#rzr{r>rr?r@rArBrCrDrErFrGrHrIrJrKrLrMrNrOrPrQrRrSrTrUrVrWrXrZr[r\r]rYr)rrrrrrr#rr7r7r8rs`> %zAsyncCompletions.streamrr7r7r7r8r0As  Vc@seZdZdddddZdS)r1r/Nonerr3cCs||_t|j|_dSN) _completionsr Zto_raw_response_wrapperrr6rr7r7r8__init__Zsz#CompletionsWithRawResponse.__init__Nrrrrr7r7r7r8r1Ysr1c@seZdZdddddZdS)rr0rrcCs||_t|j|_dSr)rr Zasync_to_raw_response_wrapperrrr7r7r8rcsz(AsyncCompletionsWithRawResponse.__init__Nrr7r7r7r8rbsrc@seZdZdddddZdS)r:r/rrcCs||_t|j|_dSr)rrrrr7r7r8rlsz)CompletionsWithStreamingResponse.__init__Nrr7r7r7r8r:ksr:c@seZdZdddddZdS)rr0rrcCs||_t|j|_dSr)rrrrr7r7r8rusz.AsyncCompletionsWithStreamingResponse.__init__Nrr7r7r7r8rtsr)Q __future__rtypingrrrrrrr functoolsr typing_extensionsr Zhttpxr _typesrrrrr_utilsrr_compatrZ _resourcerr _responserrZ _streamingrZ types.chatrZ _base_clientrZ lib._parsingrrrrrr rZtypes.chat_modelr!Zlib.streaming.chatr"r#Ztypes.shared_paramsr$r%Ztypes.chat.chat_completionr&Z types.chat.chat_completion_chunkr'Z!types.chat.parsed_chat_completionr(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__r/r0r1rr:rr7r7r7r8sJ $