google-genai 0.0.1__py3-none-any.whl

google/genai/chats.py

@@ -0,0 +1,184 @@
+# Copyright 2024 Google LLC
+#
+# 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.
+#
+
+from typing import Optional
+from typing import Union
+
+from . import _transformers as t
+from .models import AsyncModels, Models
+from .types import Content, ContentDict, GenerateContentConfigOrDict, GenerateContentResponse, PartUnionDict
+
+class _BaseChat:
+  """Base chat session."""
+
+  def __init__(
+      self,
+      *,
+      modules: Union[Models, AsyncModels],
+      model: str,
+      config: GenerateContentConfigOrDict = None,
+      history: list[Content],
+  ):
+    self._modules = modules
+    self._model = model
+    self._config = config
+    self._curated_history = history
+
+
+class Chat(_BaseChat):
+  """Chat session."""
+
+  def send_message(
+      self, message: Union[list[PartUnionDict], PartUnionDict]
+  ) -> GenerateContentResponse:
+    """Sends the conversation history with the additional message and returns the model's response.
+
+    Args:
+      message: The message to send to the model.
+
+    Returns:
+      The model's response.
+
+    Usage:
+
+    .. code-block:: python
+      chat = client.chats.create(model='gemini-1.5-flash')
+      response = chat.send_message('tell me a story')
+    """
+
+    input_content = t.t_content(self._modules.api_client, message)
+    response = self._modules.generate_content(
+        model=self._model,
+        contents=self._curated_history + [input_content],
+        config=self._config,
+    )
+    if response.candidates and response.candidates[0].content:
+      self._curated_history.append(input_content)
+      self._curated_history.append(response.candidates[0].content)
+    return response
+
+  def _send_message_stream(self, message: Union[list[ContentDict], str]):
+    for content in t.t_contents(self._modules.api_client, message):
+      self._curated_history.append(content)
+    for chunk in self._modules.generate_content_stream(
+        model=self._model, contents=self._curated_history, config=self._config
+    ):
+      # TODO(b/381089069): add successful response to history
+      yield chunk
+
+
+class Chats:
+  """A util class to create chat sessions."""
+
+  def __init__(self, modules: Models):
+    self._modules = modules
+
+  def create(
+      self,
+      *,
+      model: str,
+      config: GenerateContentConfigOrDict = None,
+      history: Optional[list[Content]] = None,
+  ) -> Chat:
+    """Creates a new chat session.
+
+    Args:
+      model: The model to use for the chat.
+      config: The configuration to use for the generate content request.
+      history: The history to use for the chat.
+
+    Returns:
+      A new chat session.
+    """
+    return Chat(
+        modules=self._modules,
+        model=model,
+        config=config,
+        history=history if history else [],
+    )
+
+
+class AsyncChat(_BaseChat):
+  """Async chat session."""
+
+  async def send_message(
+      self, message: Union[list[PartUnionDict], PartUnionDict]
+  ) -> GenerateContentResponse:
+    """Sends the conversation history with the additional message and returns model's response.
+
+    Args:
+      message: The message to send to the model.
+
+    Returns:
+      The model's response.
+
+    Usage:
+
+    .. code-block:: python
+      chat = client.chats.create(model='gemini-1.5-flash')
+      response = chat.send_message('tell me a story')
+    """
+
+    input_content = t.t_content(self._modules.api_client, message)
+    response = await self._modules.generate_content(
+        model=self._model,
+        contents=self._curated_history + [input_content],
+        config=self._config,
+    )
+    if response.candidates and response.candidates[0].content:
+      self._curated_history.append(input_content)
+      self._curated_history.append(response.candidates[0].content)
+    return response
+
+  async def _send_message_stream(self, message: Union[list[ContentDict], str]):
+    for content in t.t_contents(self._modules.api_client, message):
+      self._curated_history.append(content)
+    async for chunk in self._modules.generate_content_stream(
+        model=self._model, contents=self._curated_history, config=self._config
+    ):
+      # TODO(b/381089069): add successful response to history
+      yield chunk
+
+
+class AsyncChats:
+  """A util class to create async chat sessions."""
+
+
+  def __init__(self, modules: AsyncModels):
+    self._modules = modules
+
+  def create(
+      self,
+      *,
+      model: str,
+      config: GenerateContentConfigOrDict = None,
+      history: Optional[list[Content]] = None,
+  ) -> AsyncChat:
+    """Creates a new chat session.
+
+    Args:
+      model: The model to use for the chat.
+      config: The configuration to use for the generate content request.
+      history: The history to use for the chat.
+
+    Returns:
+      A new chat session.
+    """
+    return AsyncChat(
+        modules=self._modules,
+        model=model,
+        config=config,
+        history=history if history else [],
+    )

google/genai/client.py

@@ -0,0 +1,277 @@
+# Copyright 2024 Google LLC
+#
+# 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.
+#
+
+import os
+from typing import Optional
+
+import google.auth
+import pydantic
+
+from ._api_client import ApiClient, HttpOptions
+from ._replay_api_client import ReplayApiClient
+from .batches import AsyncBatches, Batches
+from .caches import AsyncCaches, Caches
+from .chats import AsyncChats, Chats
+from .files import AsyncFiles, Files
+from .live import AsyncLive
+from .models import AsyncModels, Models
+from .tunings import AsyncTunings, Tunings
+
+
+class AsyncClient:
+  """Client for making asynchronous (non-blocking) requests."""
+
+  def __init__(self, api_client: ApiClient):
+
+    self._api_client = api_client
+    self._models = AsyncModels(self._api_client)
+    self._tunings = AsyncTunings(self._api_client)
+    self._caches = AsyncCaches(self._api_client)
+    self._batches = AsyncBatches(self._api_client)
+    self._files = AsyncFiles(self._api_client)
+    self._live = AsyncLive(self._api_client)
+
+  @property
+  def models(self) -> AsyncModels:
+    return self._models
+
+  @property
+  def tunings(self) -> AsyncTunings:
+    return self._tunings
+
+  @property
+  def caches(self) -> AsyncCaches:
+    return self._caches
+
+  @property
+  def batches(self) -> AsyncBatches:
+    return self._batches
+
+  @property
+  def chats(self) -> AsyncChats:
+    return AsyncChats(modules=self.models)
+
+  @property
+  def files(self) -> AsyncFiles:
+    return self._files
+
+  @property
+  def live(self) -> AsyncLive:
+    return self._live
+
+
+class DebugConfig(pydantic.BaseModel):
+  """Configuration options that change client network behavior when testing."""
+
+  client_mode: Optional[str] = pydantic.Field(
+      default_factory=lambda: os.getenv('GOOGLE_GENAI_CLIENT_MODE', None)
+  )
+
+  replays_directory: Optional[str] = pydantic.Field(
+      default_factory=lambda: os.getenv('GOOGLE_GENAI_REPLAYS_DIRECTORY', None)
+  )
+
+  replay_id: Optional[str] = pydantic.Field(
+      default_factory=lambda: os.getenv('GOOGLE_GENAI_REPLAY_ID', None)
+  )
+
+
+class Client:
+  """Client for making synchronous requests.
+
+  Use this client to make a request to the Gemini Developer API or Vertex AI
+  API and then wait for the response.
+
+  Attributes:
+    api_key: The `API key <https://ai.google.dev/gemini-api/docs/api-key>`_ to
+      use for authentication. Applies to the Gemini Developer API only.
+    vertexai: Indicates whether the client should use the Vertex AI
+      API endpoints. Defaults to False (uses Gemini Developer API endpoints).
+      Applies to the Vertex AI API only.
+    credentials: The credentials to use for authentication when calling the
+      Vertex AI APIs. Credentials can be obtained from environment variables and
+      default credentials. For more information, see
+      `Set up Application Default Credentials
+      <https://cloud.google.com/docs/authentication/provide-credentials-adc>`_.
+      Applies to the Vertex AI API only.
+    project: The `Google Cloud project ID <https://cloud.google.com/vertex-ai/docs/start/cloud-environment>`_ to
+      use for quota. Can be obtained from environment variables (for example,
+      ``GOOGLE_CLOUD_PROJECT``). Applies to the Vertex AI API only.
+    location: The `location <https://cloud.google.com/vertex-ai/generative-ai/docs/learn/locations>`_
+      to send API requests to (for example, ``us-central1``). Can be obtained
+      from environment variables. Applies to the Vertex AI API only.
+    debug_config: Config settings that control network behavior of the client.
+      This is typically used when running test code.
+    http_options: Http options to use for the client. Response_payload can't be
+      set when passing to the client constructor.
+
+  Usage for the Gemini Developer API:
+
+  .. code-block:: python
+
+    from google import genai
+
+    client = genai.Client(api_key='my-api-key')
+
+  Usage for the Vertex AI API:
+
+  .. code-block:: python
+
+    from google import genai
+
+    client = genai.Client(
+        vertexai=True, project='my-project-id', location='us-central1'
+    )
+  """
+
+  def __init__(
+      self,
+      *,
+      vertexai: Optional[bool] = None,
+      api_key: Optional[str] = None,
+      credentials: Optional[google.auth.credentials.Credentials] = None,
+      project: Optional[str] = None,
+      location: Optional[str] = None,
+      debug_config: Optional[DebugConfig] = None,
+      http_options: Optional[HttpOptions] = None,
+  ):
+    """Initializes the client.
+
+       Args:
+          vertexai (bool):
+              Indicates whether the client should use the Vertex AI
+              API endpoints. Defaults to False (uses Gemini Developer API
+              endpoints). Applies to the Vertex AI API only.
+          api_key (str):
+              The `API key
+              <https://ai.google.dev/gemini-api/docs/api-key>`_ to use for
+              authentication. Applies to the Gemini Developer API only.
+          credentials (google.auth.credentials.Credentials):
+              The credentials to
+              use for authentication when calling the Vertex AI APIs. Credentials
+              can be obtained from environment variables and default credentials.
+              For more information, see `Set up Application Default Credentials
+              <https://cloud.google.com/docs/authentication/provide-credentials-adc>`_.
+              Applies to the Vertex AI API only.
+          project (str):
+              The `Google Cloud project ID
+              <https://cloud.google.com/vertex-ai/docs/start/cloud-environment>`_ to
+              use for quota. Can be obtained from environment variables (for
+              example, ``GOOGLE_CLOUD_PROJECT``). Applies to the Vertex AI API only.
+          location (str):
+              The `location
+              <https://cloud.google.com/vertex-ai/generative-ai/docs/learn/locations>`_
+              to send API requests to (for example, ``us-central1``). Can be
+              obtained from environment variables. Applies to the Vertex AI API
+              only.
+          debug_config (DebugConfig):
+              Config settings that control network
+              behavior of the client. This is typically used when running test code.
+    """
+
+    self._debug_config = debug_config or DebugConfig()
+
+    # Throw ValueError if response_payload is set in http_options due to
+    # unpredical behavior when running multiple coroutines through client.aio.
+    if http_options and 'response_payload' in http_options:
+      raise ValueError(
+          'Setting response_payload in http_options is not supported.'
+      )
+
+    self._api_client = self._get_api_client(
+        vertexai=vertexai,
+        api_key=api_key,
+        credentials=credentials,
+        project=project,
+        location=location,
+        debug_config=self._debug_config,
+        http_options=http_options,
+    )
+
+    self._aio = AsyncClient(self._api_client)
+    self._models = Models(self._api_client)
+    self._tunings = Tunings(self._api_client)
+    self._caches = Caches(self._api_client)
+    self._batches = Batches(self._api_client)
+    self._files = Files(self._api_client)
+
+  @staticmethod
+  def _get_api_client(
+      vertexai: Optional[bool] = None,
+      api_key: Optional[str] = None,
+      credentials: Optional[google.auth.credentials.Credentials] = None,
+      project: Optional[str] = None,
+      location: Optional[str] = None,
+      debug_config: Optional[DebugConfig] = None,
+      http_options: Optional[HttpOptions] = None,
+  ):
+    if debug_config and debug_config.client_mode in [
+        'record',
+        'replay',
+        'auto',
+    ]:
+      return ReplayApiClient(
+          mode=debug_config.client_mode,
+          replay_id=debug_config.replay_id,
+          replays_directory=debug_config.replays_directory,
+          vertexai=vertexai,
+          api_key=api_key,
+          credentials=credentials,
+          project=project,
+          location=location,
+          http_options=http_options,
+      )
+
+    return ApiClient(
+        vertexai=vertexai,
+        api_key=api_key,
+        credentials=credentials,
+        project=project,
+        location=location,
+        http_options=http_options,
+    )
+
+  @property
+  def chats(self) -> Chats:
+    return Chats(modules=self.models)
+
+  @property
+  def aio(self) -> AsyncClient:
+    return self._aio
+
+  @property
+  def models(self) -> Models:
+    return self._models
+
+  @property
+  def tunings(self) -> Tunings:
+    return self._tunings
+
+  @property
+  def caches(self) -> Caches:
+    return self._caches
+
+  @property
+  def batches(self) -> Batches:
+    return self._batches
+
+  @property
+  def files(self) -> Files:
+    return self._files
+
+  @property
+  def vertexai(self) -> bool:
+    """Returns whether the client is using the Vertex AI API."""
+    return self._api_client.vertexai or False

google/genai/errors.py

@@ -0,0 +1,110 @@
+# Copyright 2024 Google LLC
+#
+# 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.
+#
+
+"""Error classes for the GenAI SDK."""
+
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+import requests
+
+
+if TYPE_CHECKING:
+  from .replay_api_client import ReplayResponse
+
+
+class APIError(Exception):
+  """General errors raised by the GenAI API."""
+  code: int
+  response: requests.Response
+
+  message: str = ''
+  status: str = 'UNKNOWN'
+  details: Optional[Any] = None
+
+  def __init__(
+      self, code: int, response: Union[requests.Response, 'ReplayResponse']
+  ):
+    self.code = code
+    self.response = response
+
+    if isinstance(response, requests.Response):
+      try:
+        raw_error = response.json().get('error', {})
+      except requests.exceptions.JSONDecodeError:
+        raw_error = {'message': response.text, 'status': response.reason}
+    else:
+      raw_error = response.body_segments[0].get('error', {})
+
+    self.message = raw_error.get('message', '')
+    self.status = raw_error.get('status', 'UNKNOWN')
+    self.details = raw_error.get('details', None)
+
+    super().__init__(f'{self.code} {self.status}. {self.message}')
+
+  def _to_replay_record(self):
+    """Returns a dictionary representation of the error for replay recording.
+
+    details is not included since it may expose internal information in the
+    replay file.
+    """
+    return {
+        'error': {
+            'code': self.code,
+            'message': self.message,
+            'status': self.status,
+        }
+    }
+
+  @classmethod
+  def raise_for_response(
+      cls, response: Union[requests.Response, 'ReplayResponse']
+  ):
+    """Raises an error with detailed error message if the response has an error status."""
+    if response.status_code == 200:
+      return
+
+    status_code = response.status_code
+    if 400 <= status_code < 500:
+      raise ClientError(status_code, response)
+    elif 500 <= status_code < 600:
+      raise ServerError(status_code, response)
+    else:
+      raise cls(status_code, response)
+
+
+class ClientError(APIError):
+  """Client error raised by the GenAI API."""
+  pass
+
+
+class ServerError(APIError):
+  """Server error raised by the GenAI API."""
+  pass
+
+
+class UnkownFunctionCallArgumentError(ValueError):
+  """Raised when the function call argument cannot be converted to the parameter annotation."""
+
+  pass
+
+
+class UnsupportedFunctionError(ValueError):
+  """Raised when the function is not supported."""
+
+
+class FunctionInvocationError(ValueError):
+  """Raised when the function cannot be invoked with the given arguments."""
+
+  pass