Add files using upload-large-folder tool

parrot/lib/python3.10/site-packages/fire/completion_test.py

@@ -0,0 +1,193 @@
+# Copyright (C) 2018 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Tests for the completion module."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from fire import completion
+from fire import test_components as tc
+from fire import testutils
+
+
+class TabCompletionTest(testutils.BaseTestCase):
+
+  def testCompletionBashScript(self):
+    # A sanity check test to make sure the bash completion script satisfies
+    # some basic assumptions.
+    commands = [
+        ['run'],
+        ['halt'],
+        ['halt', '--now'],
+    ]
+    script = completion._BashScript(name='command', commands=commands)  # pylint: disable=protected-access
+    self.assertIn('command', script)
+    self.assertIn('halt', script)
+
+    assert_template = '{command})'
+    for last_command in ['command', 'halt']:
+      self.assertIn(assert_template.format(command=last_command), script)
+
+  def testCompletionFishScript(self):
+    # A sanity check test to make sure the fish completion script satisfies
+    # some basic assumptions.
+    commands = [
+        ['run'],
+        ['halt'],
+        ['halt', '--now'],
+    ]
+    script = completion._FishScript(name='command', commands=commands)  # pylint: disable=protected-access
+    self.assertIn('command', script)
+    self.assertIn('halt', script)
+    self.assertIn('-l now', script)
+
+  def testFnCompletions(self):
+    def example(one, two, three):
+      return one, two, three
+
+    completions = completion.Completions(example)
+    self.assertIn('--one', completions)
+    self.assertIn('--two', completions)
+    self.assertIn('--three', completions)
+
+  def testListCompletions(self):
+    completions = completion.Completions(['red', 'green', 'blue'])
+    self.assertIn('0', completions)
+    self.assertIn('1', completions)
+    self.assertIn('2', completions)
+    self.assertNotIn('3', completions)
+
+  def testDictCompletions(self):
+    colors = {
+        'red': 'green',
+        'blue': 'yellow',
+        '_rainbow': True,
+    }
+    completions = completion.Completions(colors)
+    self.assertIn('red', completions)
+    self.assertIn('blue', completions)
+    self.assertNotIn('green', completions)
+    self.assertNotIn('yellow', completions)
+    self.assertNotIn('_rainbow', completions)
+    self.assertNotIn('True', completions)
+    self.assertNotIn(True, completions)
+
+  def testDictCompletionsVerbose(self):
+    colors = {
+        'red': 'green',
+        'blue': 'yellow',
+        '_rainbow': True,
+    }
+    completions = completion.Completions(colors, verbose=True)
+    self.assertIn('red', completions)
+    self.assertIn('blue', completions)
+    self.assertNotIn('green', completions)
+    self.assertNotIn('yellow', completions)
+    self.assertIn('_rainbow', completions)
+    self.assertNotIn('True', completions)
+    self.assertNotIn(True, completions)
+
+  def testDeepDictCompletions(self):
+    deepdict = {'level1': {'level2': {'level3': {'level4': {}}}}}
+    completions = completion.Completions(deepdict)
+    self.assertIn('level1', completions)
+    self.assertNotIn('level2', completions)
+
+  def testDeepDictScript(self):
+    deepdict = {'level1': {'level2': {'level3': {'level4': {}}}}}
+    script = completion.Script('deepdict', deepdict)
+    self.assertIn('level1', script)
+    self.assertIn('level2', script)
+    self.assertIn('level3', script)
+    self.assertNotIn('level4', script)  # The default depth is 3.
+
+  def testFnScript(self):
+    script = completion.Script('identity', tc.identity)
+    self.assertIn('--arg1', script)
+    self.assertIn('--arg2', script)
+    self.assertIn('--arg3', script)
+    self.assertIn('--arg4', script)
+
+  def testClassScript(self):
+    script = completion.Script('', tc.MixedDefaults)
+    self.assertIn('ten', script)
+    self.assertIn('sum', script)
+    self.assertIn('identity', script)
+    self.assertIn('--alpha', script)
+    self.assertIn('--beta', script)
+
+  def testDeepDictFishScript(self):
+    deepdict = {'level1': {'level2': {'level3': {'level4': {}}}}}
+    script = completion.Script('deepdict', deepdict, shell='fish')
+    self.assertIn('level1', script)
+    self.assertIn('level2', script)
+    self.assertIn('level3', script)
+    self.assertNotIn('level4', script)  # The default depth is 3.
+
+  def testFnFishScript(self):
+    script = completion.Script('identity', tc.identity, shell='fish')
+    self.assertIn('arg1', script)
+    self.assertIn('arg2', script)
+    self.assertIn('arg3', script)
+    self.assertIn('arg4', script)
+
+  def testClassFishScript(self):
+    script = completion.Script('', tc.MixedDefaults, shell='fish')
+    self.assertIn('ten', script)
+    self.assertIn('sum', script)
+    self.assertIn('identity', script)
+    self.assertIn('alpha', script)
+    self.assertIn('beta', script)
+
+  def testNonStringDictCompletions(self):
+    completions = completion.Completions({
+        10: 'green',
+        3.14: 'yellow',
+        ('t1', 't2'): 'pink',
+    })
+    self.assertIn('10', completions)
+    self.assertIn('3.14', completions)
+    self.assertIn("('t1', 't2')", completions)
+    self.assertNotIn('green', completions)
+    self.assertNotIn('yellow', completions)
+    self.assertNotIn('pink', completions)
+
+  def testGeneratorCompletions(self):
+    def generator():
+      x = 0
+      while True:
+        yield x
+        x += 1
+    completions = completion.Completions(generator())
+    self.assertEqual(completions, [])
+
+  def testClassCompletions(self):
+    completions = completion.Completions(tc.NoDefaults)
+    self.assertEqual(completions, [])
+
+  def testObjectCompletions(self):
+    completions = completion.Completions(tc.NoDefaults())
+    self.assertIn('double', completions)
+    self.assertIn('triple', completions)
+
+  def testMethodCompletions(self):
+    completions = completion.Completions(tc.NoDefaults().double)
+    self.assertNotIn('--self', completions)
+    self.assertIn('--count', completions)
+
+
+if __name__ == '__main__':
+  testutils.main()

parrot/lib/python3.10/site-packages/fire/interact.py

@@ -0,0 +1,99 @@
+# Copyright (C) 2018 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""This module enables interactive mode in Python Fire.
+
+It uses IPython as an optional dependency. When IPython is installed, the
+interactive flag will use IPython's REPL. When IPython is not installed, the
+interactive flag will start a Python REPL with the builtin `code` module's
+InteractiveConsole class.
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import inspect
+
+
+def Embed(variables, verbose=False):
+  """Drops into a Python REPL with variables available as local variables.
+
+  Args:
+    variables: A dict of variables to make available. Keys are variable names.
+        Values are variable values.
+    verbose: Whether to include 'hidden' members, those keys starting with _.
+  """
+  print(_AvailableString(variables, verbose))
+
+  try:
+    _EmbedIPython(variables)
+  except ImportError:
+    _EmbedCode(variables)
+
+
+def _AvailableString(variables, verbose=False):
+  """Returns a string describing what objects are available in the Python REPL.
+
+  Args:
+    variables: A dict of the object to be available in the REPL.
+    verbose: Whether to include 'hidden' members, those keys starting with _.
+  Returns:
+    A string fit for printing at the start of the REPL, indicating what objects
+    are available for the user to use.
+  """
+  modules = []
+  other = []
+  for name, value in variables.items():
+    if not verbose and name.startswith('_'):
+      continue
+    if '-' in name or '/' in name:
+      continue
+
+    if inspect.ismodule(value):
+      modules.append(name)
+    else:
+      other.append(name)
+
+  lists = [
+      ('Modules', modules),
+      ('Objects', other)]
+  liststrs = []
+  for name, varlist in lists:
+    if varlist:
+      liststrs.append(
+          '{name}: {items}'.format(name=name, items=', '.join(sorted(varlist))))
+
+  return (
+      'Fire is starting a Python REPL with the following objects:\n'
+      '{liststrs}\n'
+  ).format(liststrs='\n'.join(liststrs))
+
+
+def _EmbedIPython(variables, argv=None):
+  """Drops into an IPython REPL with variables available for use.
+
+  Args:
+    variables: A dict of variables to make available. Keys are variable names.
+        Values are variable values.
+    argv: The argv to use for starting ipython. Defaults to an empty list.
+  """
+  import IPython  # pylint: disable=import-outside-toplevel,g-import-not-at-top
+  argv = argv or []
+  IPython.start_ipython(argv=argv, user_ns=variables)
+
+
+def _EmbedCode(variables):
+  import code  # pylint: disable=import-outside-toplevel,g-import-not-at-top
+  code.InteractiveConsole(variables).interact()

parrot/lib/python3.10/site-packages/fire/testutils_test.py

@@ -0,0 +1,59 @@
+# Copyright (C) 2018 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Test the test utilities for Fire's tests."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import sys
+
+from fire import testutils
+
+import six
+
+
+class TestTestUtils(testutils.BaseTestCase):
+  """Let's get meta."""
+
+  def testNoCheckOnException(self):
+    with self.assertRaises(ValueError):
+      with self.assertOutputMatches(stdout='blah'):
+        raise ValueError()
+
+  def testCheckStdoutOrStderrNone(self):
+    with six.assertRaisesRegex(self, AssertionError, 'stdout:'):
+      with self.assertOutputMatches(stdout=None):
+        print('blah')
+
+    with six.assertRaisesRegex(self, AssertionError, 'stderr:'):
+      with self.assertOutputMatches(stderr=None):
+        print('blah', file=sys.stderr)
+
+    with six.assertRaisesRegex(self, AssertionError, 'stderr:'):
+      with self.assertOutputMatches(stdout='apple', stderr=None):
+        print('apple')
+        print('blah', file=sys.stderr)
+
+  def testCorrectOrderingOfAssertRaises(self):
+    # Check to make sure FireExit tests are correct.
+    with self.assertOutputMatches(stdout='Yep.*first.*second'):
+      with self.assertRaises(ValueError):
+        print('Yep, this is the first line.\nThis is the second.')
+        raise ValueError()
+
+
+if __name__ == '__main__':
+  testutils.main()

parrot/lib/python3.10/site-packages/mdurl-0.1.2.dist-info/METADATA

@@ -0,0 +1,32 @@
+Metadata-Version: 2.1
+Name: mdurl
+Version: 0.1.2
+Summary: Markdown URL utilities
+Keywords: markdown,commonmark
+Author-email: Taneli Hukkinen <hukkin@users.noreply.github.com>
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Project-URL: Homepage, https://github.com/executablebooks/mdurl
+
+# mdurl
+
+[![Build Status](https://github.com/executablebooks/mdurl/workflows/Tests/badge.svg?branch=master)](https://github.com/executablebooks/mdurl/actions?query=workflow%3ATests+branch%3Amaster+event%3Apush)
+[![codecov.io](https://codecov.io/gh/executablebooks/mdurl/branch/master/graph/badge.svg)](https://codecov.io/gh/executablebooks/mdurl)
+[![PyPI version](https://img.shields.io/pypi/v/mdurl)](https://pypi.org/project/mdurl)
+
+This is a Python port of the JavaScript [mdurl](https://www.npmjs.com/package/mdurl) package.
+See the [upstream README.md file](https://github.com/markdown-it/mdurl/blob/master/README.md) for API documentation.
+

parrot/lib/python3.10/site-packages/openai/types/audio/__init__.py

@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless.
+
+from __future__ import annotations
+
+from .translation import Translation as Translation
+from .transcription import Transcription as Transcription
+from .speech_create_params import SpeechCreateParams as SpeechCreateParams
+from .translation_create_params import (
+    TranslationCreateParams as TranslationCreateParams,
+)
+from .transcription_create_params import (
+    TranscriptionCreateParams as TranscriptionCreateParams,
+)

parrot/lib/python3.10/site-packages/openai/types/audio/speech_create_params.py

@@ -0,0 +1,34 @@
+# File generated from our OpenAPI spec by Stainless.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["SpeechCreateParams"]
+
+
+class SpeechCreateParams(TypedDict, total=False):
+    input: Required[str]
+    """The text to generate audio for. The maximum length is 4096 characters."""
+
+    model: Required[Union[str, Literal["tts-1", "tts-1-hd"]]]
+    """
+    One of the available [TTS models](https://platform.openai.com/docs/models/tts):
+    `tts-1` or `tts-1-hd`
+    """
+
+    voice: Required[Literal["alloy", "echo", "fable", "onyx", "nova", "shimmer"]]
+    """The voice to use when generating the audio.
+
+    Supported voices are `alloy`, `echo`, `fable`, `onyx`, `nova`, and `shimmer`.
+    """
+
+    response_format: Literal["mp3", "opus", "aac", "flac"]
+    """The format to audio in. Supported formats are `mp3`, `opus`, `aac`, and `flac`."""
+
+    speed: float
+    """The speed of the generated audio.
+
+    Select a value from `0.25` to `4.0`. `1.0` is the default.
+    """

parrot/lib/python3.10/site-packages/openai/types/audio/transcription.py

@@ -0,0 +1,9 @@
+# File generated from our OpenAPI spec by Stainless.
+
+from ..._models import BaseModel
+
+__all__ = ["Transcription"]
+
+
+class Transcription(BaseModel):
+    text: str

parrot/lib/python3.10/site-packages/openai/types/audio/transcription_create_params.py

@@ -0,0 +1,52 @@
+# File generated from our OpenAPI spec by Stainless.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import Literal, Required, TypedDict
+
+from ..._types import FileTypes
+
+__all__ = ["TranscriptionCreateParams"]
+
+
+class TranscriptionCreateParams(TypedDict, total=False):
+    file: Required[FileTypes]
+    """
+    The audio file object (not file name) to transcribe, in one of these formats:
+    flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, or webm.
+    """
+
+    model: Required[Union[str, Literal["whisper-1"]]]
+    """ID of the model to use. Only `whisper-1` is currently available."""
+
+    language: str
+    """The language of the input audio.
+
+    Supplying the input language in
+    [ISO-639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) format will
+    improve accuracy and latency.
+    """
+
+    prompt: str
+    """An optional text to guide the model's style or continue a previous audio
+    segment.
+
+    The [prompt](https://platform.openai.com/docs/guides/speech-to-text/prompting)
+    should match the audio language.
+    """
+
+    response_format: Literal["json", "text", "srt", "verbose_json", "vtt"]
+    """
+    The format of the transcript output, in one of these options: `json`, `text`,
+    `srt`, `verbose_json`, or `vtt`.
+    """
+
+    temperature: float
+    """The sampling temperature, between 0 and 1.
+
+    Higher values like 0.8 will make the output more random, while lower values like
+    0.2 will make it more focused and deterministic. If set to 0, the model will use
+    [log probability](https://en.wikipedia.org/wiki/Log_probability) to
+    automatically increase the temperature until certain thresholds are hit.
+    """

parrot/lib/python3.10/site-packages/openai/types/audio/translation.py

@@ -0,0 +1,9 @@
+# File generated from our OpenAPI spec by Stainless.
+
+from ..._models import BaseModel
+
+__all__ = ["Translation"]
+
+
+class Translation(BaseModel):
+    text: str

parrot/lib/python3.10/site-packages/openai/types/audio/translation_create_params.py

@@ -0,0 +1,44 @@
+# File generated from our OpenAPI spec by Stainless.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import Literal, Required, TypedDict
+
+from ..._types import FileTypes
+
+__all__ = ["TranslationCreateParams"]
+
+
+class TranslationCreateParams(TypedDict, total=False):
+    file: Required[FileTypes]
+    """
+    The audio file object (not file name) translate, in one of these formats: flac,
+    mp3, mp4, mpeg, mpga, m4a, ogg, wav, or webm.
+    """
+
+    model: Required[Union[str, Literal["whisper-1"]]]
+    """ID of the model to use. Only `whisper-1` is currently available."""
+
+    prompt: str
+    """An optional text to guide the model's style or continue a previous audio
+    segment.
+
+    The [prompt](https://platform.openai.com/docs/guides/speech-to-text/prompting)
+    should be in English.
+    """
+
+    response_format: str
+    """
+    The format of the transcript output, in one of these options: `json`, `text`,
+    `srt`, `verbose_json`, or `vtt`.
+    """
+
+    temperature: float
+    """The sampling temperature, between 0 and 1.
+
+    Higher values like 0.8 will make the output more random, while lower values like
+    0.2 will make it more focused and deterministic. If set to 0, the model will use
+    [log probability](https://en.wikipedia.org/wiki/Log_probability) to
+    automatically increase the temperature until certain thresholds are hit.
+    """

parrot/lib/python3.10/site-packages/openai/types/beta/threads/__init__.py

@@ -0,0 +1,22 @@
+# File generated from our OpenAPI spec by Stainless.
+
+from __future__ import annotations
+
+from .run import Run as Run
+from .thread_message import ThreadMessage as ThreadMessage
+from .run_list_params import RunListParams as RunListParams
+from .run_create_params import RunCreateParams as RunCreateParams
+from .run_update_params import RunUpdateParams as RunUpdateParams
+from .message_list_params import MessageListParams as MessageListParams
+from .message_content_text import MessageContentText as MessageContentText
+from .message_create_params import MessageCreateParams as MessageCreateParams
+from .message_update_params import MessageUpdateParams as MessageUpdateParams
+from .message_content_image_file import (
+    MessageContentImageFile as MessageContentImageFile,
+)
+from .run_submit_tool_outputs_params import (
+    RunSubmitToolOutputsParams as RunSubmitToolOutputsParams,
+)
+from .required_action_function_tool_call import (
+    RequiredActionFunctionToolCall as RequiredActionFunctionToolCall,
+)

parrot/lib/python3.10/site-packages/openai/types/beta/threads/message_content_image_file.py

@@ -0,0 +1,22 @@
+# File generated from our OpenAPI spec by Stainless.
+
+from typing_extensions import Literal
+
+from ...._models import BaseModel
+
+__all__ = ["MessageContentImageFile", "ImageFile"]
+
+
+class ImageFile(BaseModel):
+    file_id: str
+    """
+    The [File](https://platform.openai.com/docs/api-reference/files) ID of the image
+    in the message content.
+    """
+
+
+class MessageContentImageFile(BaseModel):
+    image_file: ImageFile
+
+    type: Literal["image_file"]
+    """Always `image_file`."""

parrot/lib/python3.10/site-packages/openai/types/beta/threads/message_list_params.py

@@ -0,0 +1,39 @@
+# File generated from our OpenAPI spec by Stainless.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, TypedDict
+
+__all__ = ["MessageListParams"]
+
+
+class MessageListParams(TypedDict, total=False):
+    after: str
+    """A cursor for use in pagination.
+
+    `after` is an object ID that defines your place in the list. For instance, if
+    you make a list request and receive 100 objects, ending with obj_foo, your
+    subsequent call can include after=obj_foo in order to fetch the next page of the
+    list.
+    """
+
+    before: str
+    """A cursor for use in pagination.
+
+    `before` is an object ID that defines your place in the list. For instance, if
+    you make a list request and receive 100 objects, ending with obj_foo, your
+    subsequent call can include before=obj_foo in order to fetch the previous page
+    of the list.
+    """
+
+    limit: int
+    """A limit on the number of objects to be returned.
+
+    Limit can range between 1 and 100, and the default is 20.
+    """
+
+    order: Literal["asc", "desc"]
+    """Sort order by the `created_at` timestamp of the objects.
+
+    `asc` for ascending order and `desc` for descending order.
+    """

parrot/lib/python3.10/site-packages/openai/types/beta/threads/message_update_params.py

@@ -0,0 +1,20 @@
+# File generated from our OpenAPI spec by Stainless.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Required, TypedDict
+
+__all__ = ["MessageUpdateParams"]
+
+
+class MessageUpdateParams(TypedDict, total=False):
+    thread_id: Required[str]
+
+    metadata: Optional[object]
+    """Set of 16 key-value pairs that can be attached to an object.
+
+    This can be useful for storing additional information about the object in a
+    structured format. Keys can be a maximum of 64 characters long and values can be
+    a maxium of 512 characters long.
+    """

parrot/lib/python3.10/site-packages/openai/types/beta/threads/messages/__init__.py

@@ -0,0 +1,6 @@
+# File generated from our OpenAPI spec by Stainless.
+
+from __future__ import annotations
+
+from .message_file import MessageFile as MessageFile
+from .file_list_params import FileListParams as FileListParams

parrot/lib/python3.10/site-packages/openai/types/beta/threads/messages/file_list_params.py

@@ -0,0 +1,41 @@
+# File generated from our OpenAPI spec by Stainless.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["FileListParams"]
+
+
+class FileListParams(TypedDict, total=False):
+    thread_id: Required[str]
+
+    after: str
+    """A cursor for use in pagination.
+
+    `after` is an object ID that defines your place in the list. For instance, if
+    you make a list request and receive 100 objects, ending with obj_foo, your
+    subsequent call can include after=obj_foo in order to fetch the next page of the
+    list.
+    """
+
+    before: str
+    """A cursor for use in pagination.
+
+    `before` is an object ID that defines your place in the list. For instance, if
+    you make a list request and receive 100 objects, ending with obj_foo, your
+    subsequent call can include before=obj_foo in order to fetch the previous page
+    of the list.
+    """
+
+    limit: int
+    """A limit on the number of objects to be returned.
+
+    Limit can range between 1 and 100, and the default is 20.
+    """
+
+    order: Literal["asc", "desc"]
+    """Sort order by the `created_at` timestamp of the objects.
+
+    `asc` for ascending order and `desc` for descending order.
+    """

parrot/lib/python3.10/site-packages/openai/types/beta/threads/messages/message_file.py

@@ -0,0 +1,25 @@
+# File generated from our OpenAPI spec by Stainless.
+
+from typing_extensions import Literal
+
+from ....._models import BaseModel
+
+__all__ = ["MessageFile"]
+
+
+class MessageFile(BaseModel):
+    id: str
+    """The identifier, which can be referenced in API endpoints."""
+
+    created_at: int
+    """The Unix timestamp (in seconds) for when the message file was created."""
+
+    message_id: str
+    """
+    The ID of the [message](https://platform.openai.com/docs/api-reference/messages)
+    that the [File](https://platform.openai.com/docs/api-reference/files) is
+    attached to.
+    """
+
+    object: Literal["thread.message.file"]
+    """The object type, which is always `thread.message.file`."""

parrot/lib/python3.10/site-packages/openai/types/beta/threads/required_action_function_tool_call.py

@@ -0,0 +1,34 @@
+# File generated from our OpenAPI spec by Stainless.
+
+from typing_extensions import Literal
+
+from ...._models import BaseModel
+
+__all__ = ["RequiredActionFunctionToolCall", "Function"]
+
+
+class Function(BaseModel):
+    arguments: str
+    """The arguments that the model expects you to pass to the function."""
+
+    name: str
+    """The name of the function."""
+
+
+class RequiredActionFunctionToolCall(BaseModel):
+    id: str
+    """The ID of the tool call.
+
+    This ID must be referenced when you submit the tool outputs in using the
+    [Submit tool outputs to run](https://platform.openai.com/docs/api-reference/runs/submitToolOutputs)
+    endpoint.
+    """
+
+    function: Function
+    """The function definition."""
+
+    type: Literal["function"]
+    """The type of tool call the output is required for.
+
+    For now, this is always `function`.
+    """

parrot/lib/python3.10/site-packages/openai/types/beta/threads/run_create_params.py

@@ -0,0 +1,73 @@
+# File generated from our OpenAPI spec by Stainless.
+
+from __future__ import annotations
+
+from typing import List, Union, Optional
+from typing_extensions import Literal, Required, TypedDict
+
+from ....types import shared_params
+
+__all__ = [
+    "RunCreateParams",
+    "Tool",
+    "ToolAssistantToolsCode",
+    "ToolAssistantToolsRetrieval",
+    "ToolAssistantToolsFunction",
+]
+
+
+class RunCreateParams(TypedDict, total=False):
+    assistant_id: Required[str]
+    """
+    The ID of the
+    [assistant](https://platform.openai.com/docs/api-reference/assistants) to use to
+    execute this run.
+    """
+
+    instructions: Optional[str]
+    """Override the default system message of the assistant.
+
+    This is useful for modifying the behavior on a per-run basis.
+    """
+
+    metadata: Optional[object]
+    """Set of 16 key-value pairs that can be attached to an object.
+
+    This can be useful for storing additional information about the object in a
+    structured format. Keys can be a maximum of 64 characters long and values can be
+    a maxium of 512 characters long.
+    """
+
+    model: Optional[str]
+    """
+    The ID of the [Model](https://platform.openai.com/docs/api-reference/models) to
+    be used to execute this run. If a value is provided here, it will override the
+    model associated with the assistant. If not, the model associated with the
+    assistant will be used.
+    """
+
+    tools: Optional[List[Tool]]
+    """Override the tools the assistant can use for this run.
+
+    This is useful for modifying the behavior on a per-run basis.
+    """
+
+
+class ToolAssistantToolsCode(TypedDict, total=False):
+    type: Required[Literal["code_interpreter"]]
+    """The type of tool being defined: `code_interpreter`"""
+
+
+class ToolAssistantToolsRetrieval(TypedDict, total=False):
+    type: Required[Literal["retrieval"]]
+    """The type of tool being defined: `retrieval`"""
+
+
+class ToolAssistantToolsFunction(TypedDict, total=False):
+    function: Required[shared_params.FunctionDefinition]
+
+    type: Required[Literal["function"]]
+    """The type of tool being defined: `function`"""
+
+
+Tool = Union[ToolAssistantToolsCode, ToolAssistantToolsRetrieval, ToolAssistantToolsFunction]

parrot/lib/python3.10/site-packages/openai/types/beta/threads/run_submit_tool_outputs_params.py

@@ -0,0 +1,26 @@
+# File generated from our OpenAPI spec by Stainless.
+
+from __future__ import annotations
+
+from typing import List
+from typing_extensions import Required, TypedDict
+
+__all__ = ["RunSubmitToolOutputsParams", "ToolOutput"]
+
+
+class RunSubmitToolOutputsParams(TypedDict, total=False):
+    thread_id: Required[str]
+
+    tool_outputs: Required[List[ToolOutput]]
+    """A list of tools for which the outputs are being submitted."""
+
+
+class ToolOutput(TypedDict, total=False):
+    output: str
+    """The output of the tool call to be submitted to continue the run."""
+
+    tool_call_id: str
+    """
+    The ID of the tool call in the `required_action` object within the run object
+    the output is being submitted for.
+    """

parrot/lib/python3.10/site-packages/openai/types/beta/threads/run_update_params.py

@@ -0,0 +1,20 @@
+# File generated from our OpenAPI spec by Stainless.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Required, TypedDict
+
+__all__ = ["RunUpdateParams"]
+
+
+class RunUpdateParams(TypedDict, total=False):
+    thread_id: Required[str]
+
+    metadata: Optional[object]
+    """Set of 16 key-value pairs that can be attached to an object.
+
+    This can be useful for storing additional information about the object in a
+    structured format. Keys can be a maximum of 64 characters long and values can be
+    a maxium of 512 characters long.
+    """

parrot/lib/python3.10/site-packages/openai/types/beta/threads/runs/tool_calls_step_details.py

@@ -0,0 +1,25 @@
+# File generated from our OpenAPI spec by Stainless.
+
+from typing import List, Union
+from typing_extensions import Literal
+
+from ....._models import BaseModel
+from .code_tool_call import CodeToolCall
+from .function_tool_call import FunctionToolCall
+from .retrieval_tool_call import RetrievalToolCall
+
+__all__ = ["ToolCallsStepDetails", "ToolCall"]
+
+ToolCall = Union[CodeToolCall, RetrievalToolCall, FunctionToolCall]
+
+
+class ToolCallsStepDetails(BaseModel):
+    tool_calls: List[ToolCall]
+    """An array of tool calls the run step was involved in.
+
+    These can be associated with one of three types of tools: `code_interpreter`,
+    `retrieval`, or `function`.
+    """
+
+    type: Literal["tool_calls"]
+    """Always `tool_calls`."""

parrot/lib/python3.10/site-packages/openai/types/beta/threads/thread_message.py

@@ -0,0 +1,65 @@
+# File generated from our OpenAPI spec by Stainless.
+
+import builtins
+from typing import List, Union, Optional
+from typing_extensions import Literal
+
+from ...._models import BaseModel
+from .message_content_text import MessageContentText
+from .message_content_image_file import MessageContentImageFile
+
+__all__ = ["ThreadMessage", "Content"]
+
+Content = Union[MessageContentImageFile, MessageContentText]
+
+
+class ThreadMessage(BaseModel):
+    id: str
+    """The identifier, which can be referenced in API endpoints."""
+
+    assistant_id: Optional[str]
+    """
+    If applicable, the ID of the
+    [assistant](https://platform.openai.com/docs/api-reference/assistants) that
+    authored this message.
+    """
+
+    content: List[Content]
+    """The content of the message in array of text and/or images."""
+
+    created_at: int
+    """The Unix timestamp (in seconds) for when the message was created."""
+
+    file_ids: List[str]
+    """
+    A list of [file](https://platform.openai.com/docs/api-reference/files) IDs that
+    the assistant should use. Useful for tools like retrieval and code_interpreter
+    that can access files. A maximum of 10 files can be attached to a message.
+    """
+
+    metadata: Optional[builtins.object]
+    """Set of 16 key-value pairs that can be attached to an object.
+
+    This can be useful for storing additional information about the object in a
+    structured format. Keys can be a maximum of 64 characters long and values can be
+    a maxium of 512 characters long.
+    """
+
+    object: Literal["thread.message"]
+    """The object type, which is always `thread.message`."""
+
+    role: Literal["user", "assistant"]
+    """The entity that produced the message. One of `user` or `assistant`."""
+
+    run_id: Optional[str]
+    """
+    If applicable, the ID of the
+    [run](https://platform.openai.com/docs/api-reference/runs) associated with the
+    authoring of this message.
+    """
+
+    thread_id: str
+    """
+    The [thread](https://platform.openai.com/docs/api-reference/threads) ID that
+    this message belongs to.
+    """