a f:O@s4ddlmZddlmZmZmZmZmZddlm Z ddl m Z ddl Z ddl mZmZmZmZmZddlmZmZdd lmZdd lmZdd lmZmZmZm Z!dd l"m#Z#dd l$m%Z%m&Z&ddl'm(Z(ddl)m*Z*ddl+m,Z,ddl-m.Z.ddl/m0Z0ddl1m2Z2ddgZ3GdddeZ4GdddeZ5dS)) annotations)DictListUnionIterableOptional)partial)LiteralN) NOT_GIVENBodyQueryHeadersNotGiven)SyncAPIResourceAsyncAPIResource)Stream)completion_create_params)ResponseFormatTvalidate_input_toolsparse_chat_completiontype_to_response_format_param) ChatModel)ChatCompletionStreamManager AsyncChatCompletionStreamManager)ChatCompletionChunk)ParsedChatCompletion)ChatCompletionToolParam)ChatCompletionMessageParam) ChatCompletionStreamOptionsParam)#ChatCompletionToolChoiceOptionParam CompletionsAsyncCompletionsc@seZdZeeeeeeeeeeeeeeeeeeeedddedddddddd d d d d dd d dddddd ddddddddddZeeeeeeeeeeeeeeeeeeeedddedddddddd d d d d dd d dddddd ddddddddddZdS)r!Nresponse_formatfrequency_penalty function_call functions logit_biaslogprobs max_tokensnparallel_tool_callspresence_penaltyseed service_tierstopstream_options temperature tool_choicetools top_logprobstop_puser extra_headers extra_query extra_bodytimeout$Iterable[ChatCompletionMessageParam]Union[str, ChatModel] type[ResponseFormatT] | NotGivenOptional[float] | NotGiven0completion_create_params.FunctionCall | NotGiven6Iterable[completion_create_params.Function] | NotGiven#Optional[Dict[str, int]] | NotGivenOptional[bool] | NotGivenOptional[int] | NotGivenbool | 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%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;returncCsnt|ddi|pi}|jjjj||t||||||| | | | | |||||||||||||d}t|||dS)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.parserRrSr$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r$Zchat_completion input_tools_validate_input_tools_clientchat completionscreate_type_to_response_format_parse_chat_completionselfrRrSr$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;Zraw_completionrd_/var/www/ai-form-bot/venv/lib/python3.9/site-packages/openai/resources/beta/chat/completions.pyparse"sLJ zCompletions.parseJcompletion_create_params.ResponseFormat | type[ResponseFormatT] | NotGivenz,ChatCompletionStreamManager[ResponseFormatT]cCsjddi|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. rUbeta.chat.completions.streamTrRrSstreamr$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r$rY)rr\r]r^r_r`rrcrRrSr$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;Z api_requestrdrdrerjsN7 zCompletions.stream__name__ __module__ __qualname__r rfrjrdrdrdrer!!sdFxc@seZdZeeeeeeeeeeeeeeeeeeeedddedddddddd d d d d dd d dddddd ddddddddddZeeeeeeeeeeeeeeeeeeeedddedddddddd d d d d dd d dddddd ddddddddddZdS)r"Nr#r<r=r>r?r@rArBrCrDrErFrGrHrIrJrKrLrMrNrOrPrQcstt|ddi|pi}|jjjj||t||||||| | | | | |||||||||||||dIdH}t|||dS)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) ``` rUrVrWNrXrZrbrdrdrerfsLJ  zAsyncCompletions.parsergz1AsyncChatCompletionStreamManager[ResponseFormatT]cCspt|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. rUrhTrirk)r[r\r]r^r_r`rrlrdrdrerjisN6 zAsyncCompletions.streamrmrdrdrdrer"sdFx)6 __future__rtypingrrrrr functoolsrtyping_extensionsr Zhttpx_typesr r r rrZ _resourcerrZ _streamingrZ types.chatrZ lib._parsingrrr[rrarr`Ztypes.chat_modelrZlib.streaming.chatrrZ types.chat.chat_completion_chunkrZ!types.chat.parsed_chat_completionrZ%types.chat.chat_completion_tool_paramrZ(types.chat.chat_completion_message_paramrZ/types.chat.chat_completion_stream_options_paramrZ3types.chat.chat_completion_tool_choice_option_paramr __all__r!r"rdrdrdres*            U