Add files using upload-large-folder tool

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/__init__.py

@@ -0,0 +1,155 @@
+# -*- coding: utf-8 -*-
+# 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 google.ai.generativelanguage_v1beta3 import gapic_version as package_version
+
+__version__ = package_version.__version__
+
+
+from .services.discuss_service import DiscussServiceAsyncClient, DiscussServiceClient
+from .services.model_service import ModelServiceAsyncClient, ModelServiceClient
+from .services.permission_service import (
+    PermissionServiceAsyncClient,
+    PermissionServiceClient,
+)
+from .services.text_service import TextServiceAsyncClient, TextServiceClient
+from .types.citation import CitationMetadata, CitationSource
+from .types.discuss_service import (
+    CountMessageTokensRequest,
+    CountMessageTokensResponse,
+    Example,
+    GenerateMessageRequest,
+    GenerateMessageResponse,
+    Message,
+    MessagePrompt,
+)
+from .types.model import Model
+from .types.model_service import (
+    CreateTunedModelMetadata,
+    CreateTunedModelRequest,
+    DeleteTunedModelRequest,
+    GetModelRequest,
+    GetTunedModelRequest,
+    ListModelsRequest,
+    ListModelsResponse,
+    ListTunedModelsRequest,
+    ListTunedModelsResponse,
+    UpdateTunedModelRequest,
+)
+from .types.permission import Permission
+from .types.permission_service import (
+    CreatePermissionRequest,
+    DeletePermissionRequest,
+    GetPermissionRequest,
+    ListPermissionsRequest,
+    ListPermissionsResponse,
+    TransferOwnershipRequest,
+    TransferOwnershipResponse,
+    UpdatePermissionRequest,
+)
+from .types.safety import (
+    ContentFilter,
+    HarmCategory,
+    SafetyFeedback,
+    SafetyRating,
+    SafetySetting,
+)
+from .types.text_service import (
+    BatchEmbedTextRequest,
+    BatchEmbedTextResponse,
+    CountTextTokensRequest,
+    CountTextTokensResponse,
+    Embedding,
+    EmbedTextRequest,
+    EmbedTextResponse,
+    GenerateTextRequest,
+    GenerateTextResponse,
+    TextCompletion,
+    TextPrompt,
+)
+from .types.tuned_model import (
+    Dataset,
+    Hyperparameters,
+    TunedModel,
+    TunedModelSource,
+    TuningExample,
+    TuningExamples,
+    TuningSnapshot,
+    TuningTask,
+)
+
+__all__ = (
+    "DiscussServiceAsyncClient",
+    "ModelServiceAsyncClient",
+    "PermissionServiceAsyncClient",
+    "TextServiceAsyncClient",
+    "BatchEmbedTextRequest",
+    "BatchEmbedTextResponse",
+    "CitationMetadata",
+    "CitationSource",
+    "ContentFilter",
+    "CountMessageTokensRequest",
+    "CountMessageTokensResponse",
+    "CountTextTokensRequest",
+    "CountTextTokensResponse",
+    "CreatePermissionRequest",
+    "CreateTunedModelMetadata",
+    "CreateTunedModelRequest",
+    "Dataset",
+    "DeletePermissionRequest",
+    "DeleteTunedModelRequest",
+    "DiscussServiceClient",
+    "EmbedTextRequest",
+    "EmbedTextResponse",
+    "Embedding",
+    "Example",
+    "GenerateMessageRequest",
+    "GenerateMessageResponse",
+    "GenerateTextRequest",
+    "GenerateTextResponse",
+    "GetModelRequest",
+    "GetPermissionRequest",
+    "GetTunedModelRequest",
+    "HarmCategory",
+    "Hyperparameters",
+    "ListModelsRequest",
+    "ListModelsResponse",
+    "ListPermissionsRequest",
+    "ListPermissionsResponse",
+    "ListTunedModelsRequest",
+    "ListTunedModelsResponse",
+    "Message",
+    "MessagePrompt",
+    "Model",
+    "ModelServiceClient",
+    "Permission",
+    "PermissionServiceClient",
+    "SafetyFeedback",
+    "SafetyRating",
+    "SafetySetting",
+    "TextCompletion",
+    "TextPrompt",
+    "TextServiceClient",
+    "TransferOwnershipRequest",
+    "TransferOwnershipResponse",
+    "TunedModel",
+    "TunedModelSource",
+    "TuningExample",
+    "TuningExamples",
+    "TuningSnapshot",
+    "TuningTask",
+    "UpdatePermissionRequest",
+    "UpdateTunedModelRequest",
+)

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/gapic_metadata.json

@@ -0,0 +1,370 @@
+ {
+  "comment": "This file maps proto services/RPCs to the corresponding library clients/methods",
+  "language": "python",
+  "libraryPackage": "google.ai.generativelanguage_v1beta3",
+  "protoPackage": "google.ai.generativelanguage.v1beta3",
+  "schema": "1.0",
+  "services": {
+    "DiscussService": {
+      "clients": {
+        "grpc": {
+          "libraryClient": "DiscussServiceClient",
+          "rpcs": {
+            "CountMessageTokens": {
+              "methods": [
+                "count_message_tokens"
+              ]
+            },
+            "GenerateMessage": {
+              "methods": [
+                "generate_message"
+              ]
+            }
+          }
+        },
+        "grpc-async": {
+          "libraryClient": "DiscussServiceAsyncClient",
+          "rpcs": {
+            "CountMessageTokens": {
+              "methods": [
+                "count_message_tokens"
+              ]
+            },
+            "GenerateMessage": {
+              "methods": [
+                "generate_message"
+              ]
+            }
+          }
+        },
+        "rest": {
+          "libraryClient": "DiscussServiceClient",
+          "rpcs": {
+            "CountMessageTokens": {
+              "methods": [
+                "count_message_tokens"
+              ]
+            },
+            "GenerateMessage": {
+              "methods": [
+                "generate_message"
+              ]
+            }
+          }
+        }
+      }
+    },
+    "ModelService": {
+      "clients": {
+        "grpc": {
+          "libraryClient": "ModelServiceClient",
+          "rpcs": {
+            "CreateTunedModel": {
+              "methods": [
+                "create_tuned_model"
+              ]
+            },
+            "DeleteTunedModel": {
+              "methods": [
+                "delete_tuned_model"
+              ]
+            },
+            "GetModel": {
+              "methods": [
+                "get_model"
+              ]
+            },
+            "GetTunedModel": {
+              "methods": [
+                "get_tuned_model"
+              ]
+            },
+            "ListModels": {
+              "methods": [
+                "list_models"
+              ]
+            },
+            "ListTunedModels": {
+              "methods": [
+                "list_tuned_models"
+              ]
+            },
+            "UpdateTunedModel": {
+              "methods": [
+                "update_tuned_model"
+              ]
+            }
+          }
+        },
+        "grpc-async": {
+          "libraryClient": "ModelServiceAsyncClient",
+          "rpcs": {
+            "CreateTunedModel": {
+              "methods": [
+                "create_tuned_model"
+              ]
+            },
+            "DeleteTunedModel": {
+              "methods": [
+                "delete_tuned_model"
+              ]
+            },
+            "GetModel": {
+              "methods": [
+                "get_model"
+              ]
+            },
+            "GetTunedModel": {
+              "methods": [
+                "get_tuned_model"
+              ]
+            },
+            "ListModels": {
+              "methods": [
+                "list_models"
+              ]
+            },
+            "ListTunedModels": {
+              "methods": [
+                "list_tuned_models"
+              ]
+            },
+            "UpdateTunedModel": {
+              "methods": [
+                "update_tuned_model"
+              ]
+            }
+          }
+        },
+        "rest": {
+          "libraryClient": "ModelServiceClient",
+          "rpcs": {
+            "CreateTunedModel": {
+              "methods": [
+                "create_tuned_model"
+              ]
+            },
+            "DeleteTunedModel": {
+              "methods": [
+                "delete_tuned_model"
+              ]
+            },
+            "GetModel": {
+              "methods": [
+                "get_model"
+              ]
+            },
+            "GetTunedModel": {
+              "methods": [
+                "get_tuned_model"
+              ]
+            },
+            "ListModels": {
+              "methods": [
+                "list_models"
+              ]
+            },
+            "ListTunedModels": {
+              "methods": [
+                "list_tuned_models"
+              ]
+            },
+            "UpdateTunedModel": {
+              "methods": [
+                "update_tuned_model"
+              ]
+            }
+          }
+        }
+      }
+    },
+    "PermissionService": {
+      "clients": {
+        "grpc": {
+          "libraryClient": "PermissionServiceClient",
+          "rpcs": {
+            "CreatePermission": {
+              "methods": [
+                "create_permission"
+              ]
+            },
+            "DeletePermission": {
+              "methods": [
+                "delete_permission"
+              ]
+            },
+            "GetPermission": {
+              "methods": [
+                "get_permission"
+              ]
+            },
+            "ListPermissions": {
+              "methods": [
+                "list_permissions"
+              ]
+            },
+            "TransferOwnership": {
+              "methods": [
+                "transfer_ownership"
+              ]
+            },
+            "UpdatePermission": {
+              "methods": [
+                "update_permission"
+              ]
+            }
+          }
+        },
+        "grpc-async": {
+          "libraryClient": "PermissionServiceAsyncClient",
+          "rpcs": {
+            "CreatePermission": {
+              "methods": [
+                "create_permission"
+              ]
+            },
+            "DeletePermission": {
+              "methods": [
+                "delete_permission"
+              ]
+            },
+            "GetPermission": {
+              "methods": [
+                "get_permission"
+              ]
+            },
+            "ListPermissions": {
+              "methods": [
+                "list_permissions"
+              ]
+            },
+            "TransferOwnership": {
+              "methods": [
+                "transfer_ownership"
+              ]
+            },
+            "UpdatePermission": {
+              "methods": [
+                "update_permission"
+              ]
+            }
+          }
+        },
+        "rest": {
+          "libraryClient": "PermissionServiceClient",
+          "rpcs": {
+            "CreatePermission": {
+              "methods": [
+                "create_permission"
+              ]
+            },
+            "DeletePermission": {
+              "methods": [
+                "delete_permission"
+              ]
+            },
+            "GetPermission": {
+              "methods": [
+                "get_permission"
+              ]
+            },
+            "ListPermissions": {
+              "methods": [
+                "list_permissions"
+              ]
+            },
+            "TransferOwnership": {
+              "methods": [
+                "transfer_ownership"
+              ]
+            },
+            "UpdatePermission": {
+              "methods": [
+                "update_permission"
+              ]
+            }
+          }
+        }
+      }
+    },
+    "TextService": {
+      "clients": {
+        "grpc": {
+          "libraryClient": "TextServiceClient",
+          "rpcs": {
+            "BatchEmbedText": {
+              "methods": [
+                "batch_embed_text"
+              ]
+            },
+            "CountTextTokens": {
+              "methods": [
+                "count_text_tokens"
+              ]
+            },
+            "EmbedText": {
+              "methods": [
+                "embed_text"
+              ]
+            },
+            "GenerateText": {
+              "methods": [
+                "generate_text"
+              ]
+            }
+          }
+        },
+        "grpc-async": {
+          "libraryClient": "TextServiceAsyncClient",
+          "rpcs": {
+            "BatchEmbedText": {
+              "methods": [
+                "batch_embed_text"
+              ]
+            },
+            "CountTextTokens": {
+              "methods": [
+                "count_text_tokens"
+              ]
+            },
+            "EmbedText": {
+              "methods": [
+                "embed_text"
+              ]
+            },
+            "GenerateText": {
+              "methods": [
+                "generate_text"
+              ]
+            }
+          }
+        },
+        "rest": {
+          "libraryClient": "TextServiceClient",
+          "rpcs": {
+            "BatchEmbedText": {
+              "methods": [
+                "batch_embed_text"
+              ]
+            },
+            "CountTextTokens": {
+              "methods": [
+                "count_text_tokens"
+              ]
+            },
+            "EmbedText": {
+              "methods": [
+                "embed_text"
+              ]
+            },
+            "GenerateText": {
+              "methods": [
+                "generate_text"
+              ]
+            }
+          }
+        }
+      }
+    }
+  }
+}

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/gapic_version.py

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+# 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.
+#
+__version__ = "0.6.15"  # {x-release-please-version}

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/py.typed

@@ -0,0 +1,2 @@
+# Marker file for PEP 561.
+# The google-ai-generativelanguage package uses inline types.

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/services/__init__.py

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+# 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.
+#

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/services/model_service/__init__.py

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+# 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 .async_client import ModelServiceAsyncClient
+from .client import ModelServiceClient
+
+__all__ = (
+    "ModelServiceClient",
+    "ModelServiceAsyncClient",
+)

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/services/model_service/client.py

@@ -0,0 +1,1541 @@
+# -*- coding: utf-8 -*-
+# 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 collections import OrderedDict
+import logging as std_logging
+import os
+import re
+from typing import (
+    Callable,
+    Dict,
+    Mapping,
+    MutableMapping,
+    MutableSequence,
+    Optional,
+    Sequence,
+    Tuple,
+    Type,
+    Union,
+    cast,
+)
+import warnings
+
+from google.api_core import client_options as client_options_lib
+from google.api_core import exceptions as core_exceptions
+from google.api_core import gapic_v1
+from google.api_core import retry as retries
+from google.auth import credentials as ga_credentials  # type: ignore
+from google.auth.exceptions import MutualTLSChannelError  # type: ignore
+from google.auth.transport import mtls  # type: ignore
+from google.auth.transport.grpc import SslCredentials  # type: ignore
+from google.oauth2 import service_account  # type: ignore
+
+from google.ai.generativelanguage_v1beta3 import gapic_version as package_version
+
+try:
+    OptionalRetry = Union[retries.Retry, gapic_v1.method._MethodDefault, None]
+except AttributeError:  # pragma: NO COVER
+    OptionalRetry = Union[retries.Retry, object, None]  # type: ignore
+
+try:
+    from google.api_core import client_logging  # type: ignore
+
+    CLIENT_LOGGING_SUPPORTED = True  # pragma: NO COVER
+except ImportError:  # pragma: NO COVER
+    CLIENT_LOGGING_SUPPORTED = False
+
+_LOGGER = std_logging.getLogger(__name__)
+
+from google.api_core import operation  # type: ignore
+from google.api_core import operation_async  # type: ignore
+from google.longrunning import operations_pb2  # type: ignore
+from google.protobuf import field_mask_pb2  # type: ignore
+from google.protobuf import timestamp_pb2  # type: ignore
+
+from google.ai.generativelanguage_v1beta3.services.model_service import pagers
+from google.ai.generativelanguage_v1beta3.types import tuned_model as gag_tuned_model
+from google.ai.generativelanguage_v1beta3.types import model, model_service
+from google.ai.generativelanguage_v1beta3.types import tuned_model
+
+from .transports.base import DEFAULT_CLIENT_INFO, ModelServiceTransport
+from .transports.grpc import ModelServiceGrpcTransport
+from .transports.grpc_asyncio import ModelServiceGrpcAsyncIOTransport
+from .transports.rest import ModelServiceRestTransport
+
+
+class ModelServiceClientMeta(type):
+    """Metaclass for the ModelService client.
+
+    This provides class-level methods for building and retrieving
+    support objects (e.g. transport) without polluting the client instance
+    objects.
+    """
+
+    _transport_registry = OrderedDict()  # type: Dict[str, Type[ModelServiceTransport]]
+    _transport_registry["grpc"] = ModelServiceGrpcTransport
+    _transport_registry["grpc_asyncio"] = ModelServiceGrpcAsyncIOTransport
+    _transport_registry["rest"] = ModelServiceRestTransport
+
+    def get_transport_class(
+        cls,
+        label: Optional[str] = None,
+    ) -> Type[ModelServiceTransport]:
+        """Returns an appropriate transport class.
+
+        Args:
+            label: The name of the desired transport. If none is
+                provided, then the first transport in the registry is used.
+
+        Returns:
+            The transport class to use.
+        """
+        # If a specific transport is requested, return that one.
+        if label:
+            return cls._transport_registry[label]
+
+        # No transport is requested; return the default (that is, the first one
+        # in the dictionary).
+        return next(iter(cls._transport_registry.values()))
+
+
+class ModelServiceClient(metaclass=ModelServiceClientMeta):
+    """Provides methods for getting metadata information about
+    Generative Models.
+    """
+
+    @staticmethod
+    def _get_default_mtls_endpoint(api_endpoint):
+        """Converts api endpoint to mTLS endpoint.
+
+        Convert "*.sandbox.googleapis.com" and "*.googleapis.com" to
+        "*.mtls.sandbox.googleapis.com" and "*.mtls.googleapis.com" respectively.
+        Args:
+            api_endpoint (Optional[str]): the api endpoint to convert.
+        Returns:
+            str: converted mTLS api endpoint.
+        """
+        if not api_endpoint:
+            return api_endpoint
+
+        mtls_endpoint_re = re.compile(
+            r"(?P<name>[^.]+)(?P<mtls>\.mtls)?(?P<sandbox>\.sandbox)?(?P<googledomain>\.googleapis\.com)?"
+        )
+
+        m = mtls_endpoint_re.match(api_endpoint)
+        name, mtls, sandbox, googledomain = m.groups()
+        if mtls or not googledomain:
+            return api_endpoint
+
+        if sandbox:
+            return api_endpoint.replace(
+                "sandbox.googleapis.com", "mtls.sandbox.googleapis.com"
+            )
+
+        return api_endpoint.replace(".googleapis.com", ".mtls.googleapis.com")
+
+    # Note: DEFAULT_ENDPOINT is deprecated. Use _DEFAULT_ENDPOINT_TEMPLATE instead.
+    DEFAULT_ENDPOINT = "generativelanguage.googleapis.com"
+    DEFAULT_MTLS_ENDPOINT = _get_default_mtls_endpoint.__func__(  # type: ignore
+        DEFAULT_ENDPOINT
+    )
+
+    _DEFAULT_ENDPOINT_TEMPLATE = "generativelanguage.{UNIVERSE_DOMAIN}"
+    _DEFAULT_UNIVERSE = "googleapis.com"
+
+    @classmethod
+    def from_service_account_info(cls, info: dict, *args, **kwargs):
+        """Creates an instance of this client using the provided credentials
+            info.
+
+        Args:
+            info (dict): The service account private key info.
+            args: Additional arguments to pass to the constructor.
+            kwargs: Additional arguments to pass to the constructor.
+
+        Returns:
+            ModelServiceClient: The constructed client.
+        """
+        credentials = service_account.Credentials.from_service_account_info(info)
+        kwargs["credentials"] = credentials
+        return cls(*args, **kwargs)
+
+    @classmethod
+    def from_service_account_file(cls, filename: str, *args, **kwargs):
+        """Creates an instance of this client using the provided credentials
+            file.
+
+        Args:
+            filename (str): The path to the service account private key json
+                file.
+            args: Additional arguments to pass to the constructor.
+            kwargs: Additional arguments to pass to the constructor.
+
+        Returns:
+            ModelServiceClient: The constructed client.
+        """
+        credentials = service_account.Credentials.from_service_account_file(filename)
+        kwargs["credentials"] = credentials
+        return cls(*args, **kwargs)
+
+    from_service_account_json = from_service_account_file
+
+    @property
+    def transport(self) -> ModelServiceTransport:
+        """Returns the transport used by the client instance.
+
+        Returns:
+            ModelServiceTransport: The transport used by the client
+                instance.
+        """
+        return self._transport
+
+    @staticmethod
+    def model_path(
+        model: str,
+    ) -> str:
+        """Returns a fully-qualified model string."""
+        return "models/{model}".format(
+            model=model,
+        )
+
+    @staticmethod
+    def parse_model_path(path: str) -> Dict[str, str]:
+        """Parses a model path into its component segments."""
+        m = re.match(r"^models/(?P<model>.+?)$", path)
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def tuned_model_path(
+        tuned_model: str,
+    ) -> str:
+        """Returns a fully-qualified tuned_model string."""
+        return "tunedModels/{tuned_model}".format(
+            tuned_model=tuned_model,
+        )
+
+    @staticmethod
+    def parse_tuned_model_path(path: str) -> Dict[str, str]:
+        """Parses a tuned_model path into its component segments."""
+        m = re.match(r"^tunedModels/(?P<tuned_model>.+?)$", path)
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def common_billing_account_path(
+        billing_account: str,
+    ) -> str:
+        """Returns a fully-qualified billing_account string."""
+        return "billingAccounts/{billing_account}".format(
+            billing_account=billing_account,
+        )
+
+    @staticmethod
+    def parse_common_billing_account_path(path: str) -> Dict[str, str]:
+        """Parse a billing_account path into its component segments."""
+        m = re.match(r"^billingAccounts/(?P<billing_account>.+?)$", path)
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def common_folder_path(
+        folder: str,
+    ) -> str:
+        """Returns a fully-qualified folder string."""
+        return "folders/{folder}".format(
+            folder=folder,
+        )
+
+    @staticmethod
+    def parse_common_folder_path(path: str) -> Dict[str, str]:
+        """Parse a folder path into its component segments."""
+        m = re.match(r"^folders/(?P<folder>.+?)$", path)
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def common_organization_path(
+        organization: str,
+    ) -> str:
+        """Returns a fully-qualified organization string."""
+        return "organizations/{organization}".format(
+            organization=organization,
+        )
+
+    @staticmethod
+    def parse_common_organization_path(path: str) -> Dict[str, str]:
+        """Parse a organization path into its component segments."""
+        m = re.match(r"^organizations/(?P<organization>.+?)$", path)
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def common_project_path(
+        project: str,
+    ) -> str:
+        """Returns a fully-qualified project string."""
+        return "projects/{project}".format(
+            project=project,
+        )
+
+    @staticmethod
+    def parse_common_project_path(path: str) -> Dict[str, str]:
+        """Parse a project path into its component segments."""
+        m = re.match(r"^projects/(?P<project>.+?)$", path)
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def common_location_path(
+        project: str,
+        location: str,
+    ) -> str:
+        """Returns a fully-qualified location string."""
+        return "projects/{project}/locations/{location}".format(
+            project=project,
+            location=location,
+        )
+
+    @staticmethod
+    def parse_common_location_path(path: str) -> Dict[str, str]:
+        """Parse a location path into its component segments."""
+        m = re.match(r"^projects/(?P<project>.+?)/locations/(?P<location>.+?)$", path)
+        return m.groupdict() if m else {}
+
+    @classmethod
+    def get_mtls_endpoint_and_cert_source(
+        cls, client_options: Optional[client_options_lib.ClientOptions] = None
+    ):
+        """Deprecated. Return the API endpoint and client cert source for mutual TLS.
+
+        The client cert source is determined in the following order:
+        (1) if `GOOGLE_API_USE_CLIENT_CERTIFICATE` environment variable is not "true", the
+        client cert source is None.
+        (2) if `client_options.client_cert_source` is provided, use the provided one; if the
+        default client cert source exists, use the default one; otherwise the client cert
+        source is None.
+
+        The API endpoint is determined in the following order:
+        (1) if `client_options.api_endpoint` if provided, use the provided one.
+        (2) if `GOOGLE_API_USE_CLIENT_CERTIFICATE` environment variable is "always", use the
+        default mTLS endpoint; if the environment variable is "never", use the default API
+        endpoint; otherwise if client cert source exists, use the default mTLS endpoint, otherwise
+        use the default API endpoint.
+
+        More details can be found at https://google.aip.dev/auth/4114.
+
+        Args:
+            client_options (google.api_core.client_options.ClientOptions): Custom options for the
+                client. Only the `api_endpoint` and `client_cert_source` properties may be used
+                in this method.
+
+        Returns:
+            Tuple[str, Callable[[], Tuple[bytes, bytes]]]: returns the API endpoint and the
+                client cert source to use.
+
+        Raises:
+            google.auth.exceptions.MutualTLSChannelError: If any errors happen.
+        """
+
+        warnings.warn(
+            "get_mtls_endpoint_and_cert_source is deprecated. Use the api_endpoint property instead.",
+            DeprecationWarning,
+        )
+        if client_options is None:
+            client_options = client_options_lib.ClientOptions()
+        use_client_cert = os.getenv("GOOGLE_API_USE_CLIENT_CERTIFICATE", "false")
+        use_mtls_endpoint = os.getenv("GOOGLE_API_USE_MTLS_ENDPOINT", "auto")
+        if use_client_cert not in ("true", "false"):
+            raise ValueError(
+                "Environment variable `GOOGLE_API_USE_CLIENT_CERTIFICATE` must be either `true` or `false`"
+            )
+        if use_mtls_endpoint not in ("auto", "never", "always"):
+            raise MutualTLSChannelError(
+                "Environment variable `GOOGLE_API_USE_MTLS_ENDPOINT` must be `never`, `auto` or `always`"
+            )
+
+        # Figure out the client cert source to use.
+        client_cert_source = None
+        if use_client_cert == "true":
+            if client_options.client_cert_source:
+                client_cert_source = client_options.client_cert_source
+            elif mtls.has_default_client_cert_source():
+                client_cert_source = mtls.default_client_cert_source()
+
+        # Figure out which api endpoint to use.
+        if client_options.api_endpoint is not None:
+            api_endpoint = client_options.api_endpoint
+        elif use_mtls_endpoint == "always" or (
+            use_mtls_endpoint == "auto" and client_cert_source
+        ):
+            api_endpoint = cls.DEFAULT_MTLS_ENDPOINT
+        else:
+            api_endpoint = cls.DEFAULT_ENDPOINT
+
+        return api_endpoint, client_cert_source
+
+    @staticmethod
+    def _read_environment_variables():
+        """Returns the environment variables used by the client.
+
+        Returns:
+            Tuple[bool, str, str]: returns the GOOGLE_API_USE_CLIENT_CERTIFICATE,
+            GOOGLE_API_USE_MTLS_ENDPOINT, and GOOGLE_CLOUD_UNIVERSE_DOMAIN environment variables.
+
+        Raises:
+            ValueError: If GOOGLE_API_USE_CLIENT_CERTIFICATE is not
+                any of ["true", "false"].
+            google.auth.exceptions.MutualTLSChannelError: If GOOGLE_API_USE_MTLS_ENDPOINT
+                is not any of ["auto", "never", "always"].
+        """
+        use_client_cert = os.getenv(
+            "GOOGLE_API_USE_CLIENT_CERTIFICATE", "false"
+        ).lower()
+        use_mtls_endpoint = os.getenv("GOOGLE_API_USE_MTLS_ENDPOINT", "auto").lower()
+        universe_domain_env = os.getenv("GOOGLE_CLOUD_UNIVERSE_DOMAIN")
+        if use_client_cert not in ("true", "false"):
+            raise ValueError(
+                "Environment variable `GOOGLE_API_USE_CLIENT_CERTIFICATE` must be either `true` or `false`"
+            )
+        if use_mtls_endpoint not in ("auto", "never", "always"):
+            raise MutualTLSChannelError(
+                "Environment variable `GOOGLE_API_USE_MTLS_ENDPOINT` must be `never`, `auto` or `always`"
+            )
+        return use_client_cert == "true", use_mtls_endpoint, universe_domain_env
+
+    @staticmethod
+    def _get_client_cert_source(provided_cert_source, use_cert_flag):
+        """Return the client cert source to be used by the client.
+
+        Args:
+            provided_cert_source (bytes): The client certificate source provided.
+            use_cert_flag (bool): A flag indicating whether to use the client certificate.
+
+        Returns:
+            bytes or None: The client cert source to be used by the client.
+        """
+        client_cert_source = None
+        if use_cert_flag:
+            if provided_cert_source:
+                client_cert_source = provided_cert_source
+            elif mtls.has_default_client_cert_source():
+                client_cert_source = mtls.default_client_cert_source()
+        return client_cert_source
+
+    @staticmethod
+    def _get_api_endpoint(
+        api_override, client_cert_source, universe_domain, use_mtls_endpoint
+    ):
+        """Return the API endpoint used by the client.
+
+        Args:
+            api_override (str): The API endpoint override. If specified, this is always
+                the return value of this function and the other arguments are not used.
+            client_cert_source (bytes): The client certificate source used by the client.
+            universe_domain (str): The universe domain used by the client.
+            use_mtls_endpoint (str): How to use the mTLS endpoint, which depends also on the other parameters.
+                Possible values are "always", "auto", or "never".
+
+        Returns:
+            str: The API endpoint to be used by the client.
+        """
+        if api_override is not None:
+            api_endpoint = api_override
+        elif use_mtls_endpoint == "always" or (
+            use_mtls_endpoint == "auto" and client_cert_source
+        ):
+            _default_universe = ModelServiceClient._DEFAULT_UNIVERSE
+            if universe_domain != _default_universe:
+                raise MutualTLSChannelError(
+                    f"mTLS is not supported in any universe other than {_default_universe}."
+                )
+            api_endpoint = ModelServiceClient.DEFAULT_MTLS_ENDPOINT
+        else:
+            api_endpoint = ModelServiceClient._DEFAULT_ENDPOINT_TEMPLATE.format(
+                UNIVERSE_DOMAIN=universe_domain
+            )
+        return api_endpoint
+
+    @staticmethod
+    def _get_universe_domain(
+        client_universe_domain: Optional[str], universe_domain_env: Optional[str]
+    ) -> str:
+        """Return the universe domain used by the client.
+
+        Args:
+            client_universe_domain (Optional[str]): The universe domain configured via the client options.
+            universe_domain_env (Optional[str]): The universe domain configured via the "GOOGLE_CLOUD_UNIVERSE_DOMAIN" environment variable.
+
+        Returns:
+            str: The universe domain to be used by the client.
+
+        Raises:
+            ValueError: If the universe domain is an empty string.
+        """
+        universe_domain = ModelServiceClient._DEFAULT_UNIVERSE
+        if client_universe_domain is not None:
+            universe_domain = client_universe_domain
+        elif universe_domain_env is not None:
+            universe_domain = universe_domain_env
+        if len(universe_domain.strip()) == 0:
+            raise ValueError("Universe Domain cannot be an empty string.")
+        return universe_domain
+
+    def _validate_universe_domain(self):
+        """Validates client's and credentials' universe domains are consistent.
+
+        Returns:
+            bool: True iff the configured universe domain is valid.
+
+        Raises:
+            ValueError: If the configured universe domain is not valid.
+        """
+
+        # NOTE (b/349488459): universe validation is disabled until further notice.
+        return True
+
+    @property
+    def api_endpoint(self):
+        """Return the API endpoint used by the client instance.
+
+        Returns:
+            str: The API endpoint used by the client instance.
+        """
+        return self._api_endpoint
+
+    @property
+    def universe_domain(self) -> str:
+        """Return the universe domain used by the client instance.
+
+        Returns:
+            str: The universe domain used by the client instance.
+        """
+        return self._universe_domain
+
+    def __init__(
+        self,
+        *,
+        credentials: Optional[ga_credentials.Credentials] = None,
+        transport: Optional[
+            Union[str, ModelServiceTransport, Callable[..., ModelServiceTransport]]
+        ] = None,
+        client_options: Optional[Union[client_options_lib.ClientOptions, dict]] = None,
+        client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
+    ) -> None:
+        """Instantiates the model service client.
+
+        Args:
+            credentials (Optional[google.auth.credentials.Credentials]): The
+                authorization credentials to attach to requests. These
+                credentials identify the application to the service; if none
+                are specified, the client will attempt to ascertain the
+                credentials from the environment.
+            transport (Optional[Union[str,ModelServiceTransport,Callable[..., ModelServiceTransport]]]):
+                The transport to use, or a Callable that constructs and returns a new transport.
+                If a Callable is given, it will be called with the same set of initialization
+                arguments as used in the ModelServiceTransport constructor.
+                If set to None, a transport is chosen automatically.
+            client_options (Optional[Union[google.api_core.client_options.ClientOptions, dict]]):
+                Custom options for the client.
+
+                1. The ``api_endpoint`` property can be used to override the
+                default endpoint provided by the client when ``transport`` is
+                not explicitly provided. Only if this property is not set and
+                ``transport`` was not explicitly provided, the endpoint is
+                determined by the GOOGLE_API_USE_MTLS_ENDPOINT environment
+                variable, which have one of the following values:
+                "always" (always use the default mTLS endpoint), "never" (always
+                use the default regular endpoint) and "auto" (auto-switch to the
+                default mTLS endpoint if client certificate is present; this is
+                the default value).
+
+                2. If the GOOGLE_API_USE_CLIENT_CERTIFICATE environment variable
+                is "true", then the ``client_cert_source`` property can be used
+                to provide a client certificate for mTLS transport. If
+                not provided, the default SSL client certificate will be used if
+                present. If GOOGLE_API_USE_CLIENT_CERTIFICATE is "false" or not
+                set, no client certificate will be used.
+
+                3. The ``universe_domain`` property can be used to override the
+                default "googleapis.com" universe. Note that the ``api_endpoint``
+                property still takes precedence; and ``universe_domain`` is
+                currently not supported for mTLS.
+
+            client_info (google.api_core.gapic_v1.client_info.ClientInfo):
+                The client info used to send a user-agent string along with
+                API requests. If ``None``, then default info will be used.
+                Generally, you only need to set this if you're developing
+                your own client library.
+
+        Raises:
+            google.auth.exceptions.MutualTLSChannelError: If mutual TLS transport
+                creation failed for any reason.
+        """
+        self._client_options = client_options
+        if isinstance(self._client_options, dict):
+            self._client_options = client_options_lib.from_dict(self._client_options)
+        if self._client_options is None:
+            self._client_options = client_options_lib.ClientOptions()
+        self._client_options = cast(
+            client_options_lib.ClientOptions, self._client_options
+        )
+
+        universe_domain_opt = getattr(self._client_options, "universe_domain", None)
+
+        (
+            self._use_client_cert,
+            self._use_mtls_endpoint,
+            self._universe_domain_env,
+        ) = ModelServiceClient._read_environment_variables()
+        self._client_cert_source = ModelServiceClient._get_client_cert_source(
+            self._client_options.client_cert_source, self._use_client_cert
+        )
+        self._universe_domain = ModelServiceClient._get_universe_domain(
+            universe_domain_opt, self._universe_domain_env
+        )
+        self._api_endpoint = None  # updated below, depending on `transport`
+
+        # Initialize the universe domain validation.
+        self._is_universe_domain_valid = False
+
+        if CLIENT_LOGGING_SUPPORTED:  # pragma: NO COVER
+            # Setup logging.
+            client_logging.initialize_logging()
+
+        api_key_value = getattr(self._client_options, "api_key", None)
+        if api_key_value and credentials:
+            raise ValueError(
+                "client_options.api_key and credentials are mutually exclusive"
+            )
+
+        # Save or instantiate the transport.
+        # Ordinarily, we provide the transport, but allowing a custom transport
+        # instance provides an extensibility point for unusual situations.
+        transport_provided = isinstance(transport, ModelServiceTransport)
+        if transport_provided:
+            # transport is a ModelServiceTransport instance.
+            if credentials or self._client_options.credentials_file or api_key_value:
+                raise ValueError(
+                    "When providing a transport instance, "
+                    "provide its credentials directly."
+                )
+            if self._client_options.scopes:
+                raise ValueError(
+                    "When providing a transport instance, provide its scopes "
+                    "directly."
+                )
+            self._transport = cast(ModelServiceTransport, transport)
+            self._api_endpoint = self._transport.host
+
+        self._api_endpoint = self._api_endpoint or ModelServiceClient._get_api_endpoint(
+            self._client_options.api_endpoint,
+            self._client_cert_source,
+            self._universe_domain,
+            self._use_mtls_endpoint,
+        )
+
+        if not transport_provided:
+            import google.auth._default  # type: ignore
+
+            if api_key_value and hasattr(
+                google.auth._default, "get_api_key_credentials"
+            ):
+                credentials = google.auth._default.get_api_key_credentials(
+                    api_key_value
+                )
+
+            transport_init: Union[
+                Type[ModelServiceTransport], Callable[..., ModelServiceTransport]
+            ] = (
+                ModelServiceClient.get_transport_class(transport)
+                if isinstance(transport, str) or transport is None
+                else cast(Callable[..., ModelServiceTransport], transport)
+            )
+            # initialize with the provided callable or the passed in class
+            self._transport = transport_init(
+                credentials=credentials,
+                credentials_file=self._client_options.credentials_file,
+                host=self._api_endpoint,
+                scopes=self._client_options.scopes,
+                client_cert_source_for_mtls=self._client_cert_source,
+                quota_project_id=self._client_options.quota_project_id,
+                client_info=client_info,
+                always_use_jwt_access=True,
+                api_audience=self._client_options.api_audience,
+            )
+
+        if "async" not in str(self._transport):
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                std_logging.DEBUG
+            ):  # pragma: NO COVER
+                _LOGGER.debug(
+                    "Created client `google.ai.generativelanguage_v1beta3.ModelServiceClient`.",
+                    extra={
+                        "serviceName": "google.ai.generativelanguage.v1beta3.ModelService",
+                        "universeDomain": getattr(
+                            self._transport._credentials, "universe_domain", ""
+                        ),
+                        "credentialsType": f"{type(self._transport._credentials).__module__}.{type(self._transport._credentials).__qualname__}",
+                        "credentialsInfo": getattr(
+                            self.transport._credentials, "get_cred_info", lambda: None
+                        )(),
+                    }
+                    if hasattr(self._transport, "_credentials")
+                    else {
+                        "serviceName": "google.ai.generativelanguage.v1beta3.ModelService",
+                        "credentialsType": None,
+                    },
+                )
+
+    def get_model(
+        self,
+        request: Optional[Union[model_service.GetModelRequest, dict]] = None,
+        *,
+        name: Optional[str] = None,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
+    ) -> model.Model:
+        r"""Gets information about a specific Model.
+
+        .. code-block:: python
+
+            # This snippet has been automatically generated and should be regarded as a
+            # code template only.
+            # It will require modifications to work:
+            # - It may require correct/in-range values for request initialization.
+            # - It may require specifying regional endpoints when creating the service
+            #   client as shown in:
+            #   https://googleapis.dev/python/google-api-core/latest/client_options.html
+            from google.ai import generativelanguage_v1beta3
+
+            def sample_get_model():
+                # Create a client
+                client = generativelanguage_v1beta3.ModelServiceClient()
+
+                # Initialize request argument(s)
+                request = generativelanguage_v1beta3.GetModelRequest(
+                    name="name_value",
+                )
+
+                # Make the request
+                response = client.get_model(request=request)
+
+                # Handle the response
+                print(response)
+
+        Args:
+            request (Union[google.ai.generativelanguage_v1beta3.types.GetModelRequest, dict]):
+                The request object. Request for getting information about
+                a specific Model.
+            name (str):
+                Required. The resource name of the model.
+
+                This name should match a model name returned by the
+                ``ListModels`` method.
+
+                Format: ``models/{model}``
+
+                This corresponds to the ``name`` field
+                on the ``request`` instance; if ``request`` is provided, this
+                should not be set.
+            retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                sent along with the request as metadata. Normally, each value must be of type `str`,
+                but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                be of type `bytes`.
+
+        Returns:
+            google.ai.generativelanguage_v1beta3.types.Model:
+                Information about a Generative
+                Language Model.
+
+        """
+        # Create or coerce a protobuf request object.
+        # - Quick check: If we got a request object, we should *not* have
+        #   gotten any keyword arguments that map to the request.
+        has_flattened_params = any([name])
+        if request is not None and has_flattened_params:
+            raise ValueError(
+                "If the `request` argument is set, then none of "
+                "the individual field arguments should be set."
+            )
+
+        # - Use the request object if provided (there's no risk of modifying the input as
+        #   there are no flattened fields), or create one.
+        if not isinstance(request, model_service.GetModelRequest):
+            request = model_service.GetModelRequest(request)
+            # If we have keyword arguments corresponding to fields on the
+            # request, apply these.
+            if name is not None:
+                request.name = name
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = self._transport._wrapped_methods[self._transport.get_model]
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Validate the universe domain.
+        self._validate_universe_domain()
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def list_models(
+        self,
+        request: Optional[Union[model_service.ListModelsRequest, dict]] = None,
+        *,
+        page_size: Optional[int] = None,
+        page_token: Optional[str] = None,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
+    ) -> pagers.ListModelsPager:
+        r"""Lists models available through the API.
+
+        .. code-block:: python
+
+            # This snippet has been automatically generated and should be regarded as a
+            # code template only.
+            # It will require modifications to work:
+            # - It may require correct/in-range values for request initialization.
+            # - It may require specifying regional endpoints when creating the service
+            #   client as shown in:
+            #   https://googleapis.dev/python/google-api-core/latest/client_options.html
+            from google.ai import generativelanguage_v1beta3
+
+            def sample_list_models():
+                # Create a client
+                client = generativelanguage_v1beta3.ModelServiceClient()
+
+                # Initialize request argument(s)
+                request = generativelanguage_v1beta3.ListModelsRequest(
+                )
+
+                # Make the request
+                page_result = client.list_models(request=request)
+
+                # Handle the response
+                for response in page_result:
+                    print(response)
+
+        Args:
+            request (Union[google.ai.generativelanguage_v1beta3.types.ListModelsRequest, dict]):
+                The request object. Request for listing all Models.
+            page_size (int):
+                The maximum number of ``Models`` to return (per page).
+
+                The service may return fewer models. If unspecified, at
+                most 50 models will be returned per page. This method
+                returns at most 1000 models per page, even if you pass a
+                larger page_size.
+
+                This corresponds to the ``page_size`` field
+                on the ``request`` instance; if ``request`` is provided, this
+                should not be set.
+            page_token (str):
+                A page token, received from a previous ``ListModels``
+                call.
+
+                Provide the ``page_token`` returned by one request as an
+                argument to the next request to retrieve the next page.
+
+                When paginating, all other parameters provided to
+                ``ListModels`` must match the call that provided the
+                page token.
+
+                This corresponds to the ``page_token`` field
+                on the ``request`` instance; if ``request`` is provided, this
+                should not be set.
+            retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                sent along with the request as metadata. Normally, each value must be of type `str`,
+                but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                be of type `bytes`.
+
+        Returns:
+            google.ai.generativelanguage_v1beta3.services.model_service.pagers.ListModelsPager:
+                Response from ListModel containing a paginated list of
+                Models.
+
+                Iterating over this object will yield results and
+                resolve additional pages automatically.
+
+        """
+        # Create or coerce a protobuf request object.
+        # - Quick check: If we got a request object, we should *not* have
+        #   gotten any keyword arguments that map to the request.
+        has_flattened_params = any([page_size, page_token])
+        if request is not None and has_flattened_params:
+            raise ValueError(
+                "If the `request` argument is set, then none of "
+                "the individual field arguments should be set."
+            )
+
+        # - Use the request object if provided (there's no risk of modifying the input as
+        #   there are no flattened fields), or create one.
+        if not isinstance(request, model_service.ListModelsRequest):
+            request = model_service.ListModelsRequest(request)
+            # If we have keyword arguments corresponding to fields on the
+            # request, apply these.
+            if page_size is not None:
+                request.page_size = page_size
+            if page_token is not None:
+                request.page_token = page_token
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = self._transport._wrapped_methods[self._transport.list_models]
+
+        # Validate the universe domain.
+        self._validate_universe_domain()
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # This method is paged; wrap the response in a pager, which provides
+        # an `__iter__` convenience method.
+        response = pagers.ListModelsPager(
+            method=rpc,
+            request=request,
+            response=response,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def get_tuned_model(
+        self,
+        request: Optional[Union[model_service.GetTunedModelRequest, dict]] = None,
+        *,
+        name: Optional[str] = None,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
+    ) -> tuned_model.TunedModel:
+        r"""Gets information about a specific TunedModel.
+
+        .. code-block:: python
+
+            # This snippet has been automatically generated and should be regarded as a
+            # code template only.
+            # It will require modifications to work:
+            # - It may require correct/in-range values for request initialization.
+            # - It may require specifying regional endpoints when creating the service
+            #   client as shown in:
+            #   https://googleapis.dev/python/google-api-core/latest/client_options.html
+            from google.ai import generativelanguage_v1beta3
+
+            def sample_get_tuned_model():
+                # Create a client
+                client = generativelanguage_v1beta3.ModelServiceClient()
+
+                # Initialize request argument(s)
+                request = generativelanguage_v1beta3.GetTunedModelRequest(
+                    name="name_value",
+                )
+
+                # Make the request
+                response = client.get_tuned_model(request=request)
+
+                # Handle the response
+                print(response)
+
+        Args:
+            request (Union[google.ai.generativelanguage_v1beta3.types.GetTunedModelRequest, dict]):
+                The request object. Request for getting information about
+                a specific Model.
+            name (str):
+                Required. The resource name of the model.
+
+                Format: ``tunedModels/my-model-id``
+
+                This corresponds to the ``name`` field
+                on the ``request`` instance; if ``request`` is provided, this
+                should not be set.
+            retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                sent along with the request as metadata. Normally, each value must be of type `str`,
+                but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                be of type `bytes`.
+
+        Returns:
+            google.ai.generativelanguage_v1beta3.types.TunedModel:
+                A fine-tuned model created using
+                ModelService.CreateTunedModel.
+
+        """
+        # Create or coerce a protobuf request object.
+        # - Quick check: If we got a request object, we should *not* have
+        #   gotten any keyword arguments that map to the request.
+        has_flattened_params = any([name])
+        if request is not None and has_flattened_params:
+            raise ValueError(
+                "If the `request` argument is set, then none of "
+                "the individual field arguments should be set."
+            )
+
+        # - Use the request object if provided (there's no risk of modifying the input as
+        #   there are no flattened fields), or create one.
+        if not isinstance(request, model_service.GetTunedModelRequest):
+            request = model_service.GetTunedModelRequest(request)
+            # If we have keyword arguments corresponding to fields on the
+            # request, apply these.
+            if name is not None:
+                request.name = name
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = self._transport._wrapped_methods[self._transport.get_tuned_model]
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Validate the universe domain.
+        self._validate_universe_domain()
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def list_tuned_models(
+        self,
+        request: Optional[Union[model_service.ListTunedModelsRequest, dict]] = None,
+        *,
+        page_size: Optional[int] = None,
+        page_token: Optional[str] = None,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
+    ) -> pagers.ListTunedModelsPager:
+        r"""Lists tuned models owned by the user.
+
+        .. code-block:: python
+
+            # This snippet has been automatically generated and should be regarded as a
+            # code template only.
+            # It will require modifications to work:
+            # - It may require correct/in-range values for request initialization.
+            # - It may require specifying regional endpoints when creating the service
+            #   client as shown in:
+            #   https://googleapis.dev/python/google-api-core/latest/client_options.html
+            from google.ai import generativelanguage_v1beta3
+
+            def sample_list_tuned_models():
+                # Create a client
+                client = generativelanguage_v1beta3.ModelServiceClient()
+
+                # Initialize request argument(s)
+                request = generativelanguage_v1beta3.ListTunedModelsRequest(
+                )
+
+                # Make the request
+                page_result = client.list_tuned_models(request=request)
+
+                # Handle the response
+                for response in page_result:
+                    print(response)
+
+        Args:
+            request (Union[google.ai.generativelanguage_v1beta3.types.ListTunedModelsRequest, dict]):
+                The request object. Request for listing TunedModels.
+            page_size (int):
+                Optional. The maximum number of ``TunedModels`` to
+                return (per page). The service may return fewer tuned
+                models.
+
+                If unspecified, at most 10 tuned models will be
+                returned. This method returns at most 1000 models per
+                page, even if you pass a larger page_size.
+
+                This corresponds to the ``page_size`` field
+                on the ``request`` instance; if ``request`` is provided, this
+                should not be set.
+            page_token (str):
+                Optional. A page token, received from a previous
+                ``ListTunedModels`` call.
+
+                Provide the ``page_token`` returned by one request as an
+                argument to the next request to retrieve the next page.
+
+                When paginating, all other parameters provided to
+                ``ListTunedModels`` must match the call that provided
+                the page token.
+
+                This corresponds to the ``page_token`` field
+                on the ``request`` instance; if ``request`` is provided, this
+                should not be set.
+            retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                sent along with the request as metadata. Normally, each value must be of type `str`,
+                but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                be of type `bytes`.
+
+        Returns:
+            google.ai.generativelanguage_v1beta3.services.model_service.pagers.ListTunedModelsPager:
+                Response from ListTunedModels containing a paginated
+                list of Models.
+
+                Iterating over this object will yield results and
+                resolve additional pages automatically.
+
+        """
+        # Create or coerce a protobuf request object.
+        # - Quick check: If we got a request object, we should *not* have
+        #   gotten any keyword arguments that map to the request.
+        has_flattened_params = any([page_size, page_token])
+        if request is not None and has_flattened_params:
+            raise ValueError(
+                "If the `request` argument is set, then none of "
+                "the individual field arguments should be set."
+            )
+
+        # - Use the request object if provided (there's no risk of modifying the input as
+        #   there are no flattened fields), or create one.
+        if not isinstance(request, model_service.ListTunedModelsRequest):
+            request = model_service.ListTunedModelsRequest(request)
+            # If we have keyword arguments corresponding to fields on the
+            # request, apply these.
+            if page_size is not None:
+                request.page_size = page_size
+            if page_token is not None:
+                request.page_token = page_token
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = self._transport._wrapped_methods[self._transport.list_tuned_models]
+
+        # Validate the universe domain.
+        self._validate_universe_domain()
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # This method is paged; wrap the response in a pager, which provides
+        # an `__iter__` convenience method.
+        response = pagers.ListTunedModelsPager(
+            method=rpc,
+            request=request,
+            response=response,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def create_tuned_model(
+        self,
+        request: Optional[Union[model_service.CreateTunedModelRequest, dict]] = None,
+        *,
+        tuned_model: Optional[gag_tuned_model.TunedModel] = None,
+        tuned_model_id: Optional[str] = None,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
+    ) -> operation.Operation:
+        r"""Creates a tuned model. Intermediate tuning progress (if any) is
+        accessed through the [google.longrunning.Operations] service.
+
+        Status and results can be accessed through the Operations
+        service. Example: GET
+        /v1/tunedModels/az2mb0bpw6i/operations/000-111-222
+
+        .. code-block:: python
+
+            # This snippet has been automatically generated and should be regarded as a
+            # code template only.
+            # It will require modifications to work:
+            # - It may require correct/in-range values for request initialization.
+            # - It may require specifying regional endpoints when creating the service
+            #   client as shown in:
+            #   https://googleapis.dev/python/google-api-core/latest/client_options.html
+            from google.ai import generativelanguage_v1beta3
+
+            def sample_create_tuned_model():
+                # Create a client
+                client = generativelanguage_v1beta3.ModelServiceClient()
+
+                # Initialize request argument(s)
+                tuned_model = generativelanguage_v1beta3.TunedModel()
+                tuned_model.tuning_task.training_data.examples.examples.text_input = "text_input_value"
+                tuned_model.tuning_task.training_data.examples.examples.output = "output_value"
+
+                request = generativelanguage_v1beta3.CreateTunedModelRequest(
+                    tuned_model=tuned_model,
+                )
+
+                # Make the request
+                operation = client.create_tuned_model(request=request)
+
+                print("Waiting for operation to complete...")
+
+                response = operation.result()
+
+                # Handle the response
+                print(response)
+
+        Args:
+            request (Union[google.ai.generativelanguage_v1beta3.types.CreateTunedModelRequest, dict]):
+                The request object. Request to create a TunedModel.
+            tuned_model (google.ai.generativelanguage_v1beta3.types.TunedModel):
+                Required. The tuned model to create.
+                This corresponds to the ``tuned_model`` field
+                on the ``request`` instance; if ``request`` is provided, this
+                should not be set.
+            tuned_model_id (str):
+                Optional. The unique id for the tuned model if
+                specified. This value should be up to 40 characters, the
+                first character must be a letter, the last could be a
+                letter or a number. The id must match the regular
+                expression: `a-z <[a-z0-9-]{0,38}[a-z0-9]>`__?.
+
+                This corresponds to the ``tuned_model_id`` field
+                on the ``request`` instance; if ``request`` is provided, this
+                should not be set.
+            retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                sent along with the request as metadata. Normally, each value must be of type `str`,
+                but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                be of type `bytes`.
+
+        Returns:
+            google.api_core.operation.Operation:
+                An object representing a long-running operation.
+
+                The result type for the operation will be
+                :class:`google.ai.generativelanguage_v1beta3.types.TunedModel`
+                A fine-tuned model created using
+                ModelService.CreateTunedModel.
+
+        """
+        # Create or coerce a protobuf request object.
+        # - Quick check: If we got a request object, we should *not* have
+        #   gotten any keyword arguments that map to the request.
+        has_flattened_params = any([tuned_model, tuned_model_id])
+        if request is not None and has_flattened_params:
+            raise ValueError(
+                "If the `request` argument is set, then none of "
+                "the individual field arguments should be set."
+            )
+
+        # - Use the request object if provided (there's no risk of modifying the input as
+        #   there are no flattened fields), or create one.
+        if not isinstance(request, model_service.CreateTunedModelRequest):
+            request = model_service.CreateTunedModelRequest(request)
+            # If we have keyword arguments corresponding to fields on the
+            # request, apply these.
+            if tuned_model is not None:
+                request.tuned_model = tuned_model
+            if tuned_model_id is not None:
+                request.tuned_model_id = tuned_model_id
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = self._transport._wrapped_methods[self._transport.create_tuned_model]
+
+        # Validate the universe domain.
+        self._validate_universe_domain()
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Wrap the response in an operation future.
+        response = operation.from_gapic(
+            response,
+            self._transport.operations_client,
+            gag_tuned_model.TunedModel,
+            metadata_type=model_service.CreateTunedModelMetadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def update_tuned_model(
+        self,
+        request: Optional[Union[model_service.UpdateTunedModelRequest, dict]] = None,
+        *,
+        tuned_model: Optional[gag_tuned_model.TunedModel] = None,
+        update_mask: Optional[field_mask_pb2.FieldMask] = None,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
+    ) -> gag_tuned_model.TunedModel:
+        r"""Updates a tuned model.
+
+        .. code-block:: python
+
+            # This snippet has been automatically generated and should be regarded as a
+            # code template only.
+            # It will require modifications to work:
+            # - It may require correct/in-range values for request initialization.
+            # - It may require specifying regional endpoints when creating the service
+            #   client as shown in:
+            #   https://googleapis.dev/python/google-api-core/latest/client_options.html
+            from google.ai import generativelanguage_v1beta3
+
+            def sample_update_tuned_model():
+                # Create a client
+                client = generativelanguage_v1beta3.ModelServiceClient()
+
+                # Initialize request argument(s)
+                tuned_model = generativelanguage_v1beta3.TunedModel()
+                tuned_model.tuning_task.training_data.examples.examples.text_input = "text_input_value"
+                tuned_model.tuning_task.training_data.examples.examples.output = "output_value"
+
+                request = generativelanguage_v1beta3.UpdateTunedModelRequest(
+                    tuned_model=tuned_model,
+                )
+
+                # Make the request
+                response = client.update_tuned_model(request=request)
+
+                # Handle the response
+                print(response)
+
+        Args:
+            request (Union[google.ai.generativelanguage_v1beta3.types.UpdateTunedModelRequest, dict]):
+                The request object. Request to update a TunedModel.
+            tuned_model (google.ai.generativelanguage_v1beta3.types.TunedModel):
+                Required. The tuned model to update.
+                This corresponds to the ``tuned_model`` field
+                on the ``request`` instance; if ``request`` is provided, this
+                should not be set.
+            update_mask (google.protobuf.field_mask_pb2.FieldMask):
+                Required. The list of fields to
+                update.
+
+                This corresponds to the ``update_mask`` field
+                on the ``request`` instance; if ``request`` is provided, this
+                should not be set.
+            retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                sent along with the request as metadata. Normally, each value must be of type `str`,
+                but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                be of type `bytes`.
+
+        Returns:
+            google.ai.generativelanguage_v1beta3.types.TunedModel:
+                A fine-tuned model created using
+                ModelService.CreateTunedModel.
+
+        """
+        # Create or coerce a protobuf request object.
+        # - Quick check: If we got a request object, we should *not* have
+        #   gotten any keyword arguments that map to the request.
+        has_flattened_params = any([tuned_model, update_mask])
+        if request is not None and has_flattened_params:
+            raise ValueError(
+                "If the `request` argument is set, then none of "
+                "the individual field arguments should be set."
+            )
+
+        # - Use the request object if provided (there's no risk of modifying the input as
+        #   there are no flattened fields), or create one.
+        if not isinstance(request, model_service.UpdateTunedModelRequest):
+            request = model_service.UpdateTunedModelRequest(request)
+            # If we have keyword arguments corresponding to fields on the
+            # request, apply these.
+            if tuned_model is not None:
+                request.tuned_model = tuned_model
+            if update_mask is not None:
+                request.update_mask = update_mask
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = self._transport._wrapped_methods[self._transport.update_tuned_model]
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata(
+                (("tuned_model.name", request.tuned_model.name),)
+            ),
+        )
+
+        # Validate the universe domain.
+        self._validate_universe_domain()
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def delete_tuned_model(
+        self,
+        request: Optional[Union[model_service.DeleteTunedModelRequest, dict]] = None,
+        *,
+        name: Optional[str] = None,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
+    ) -> None:
+        r"""Deletes a tuned model.
+
+        .. code-block:: python
+
+            # This snippet has been automatically generated and should be regarded as a
+            # code template only.
+            # It will require modifications to work:
+            # - It may require correct/in-range values for request initialization.
+            # - It may require specifying regional endpoints when creating the service
+            #   client as shown in:
+            #   https://googleapis.dev/python/google-api-core/latest/client_options.html
+            from google.ai import generativelanguage_v1beta3
+
+            def sample_delete_tuned_model():
+                # Create a client
+                client = generativelanguage_v1beta3.ModelServiceClient()
+
+                # Initialize request argument(s)
+                request = generativelanguage_v1beta3.DeleteTunedModelRequest(
+                    name="name_value",
+                )
+
+                # Make the request
+                client.delete_tuned_model(request=request)
+
+        Args:
+            request (Union[google.ai.generativelanguage_v1beta3.types.DeleteTunedModelRequest, dict]):
+                The request object. Request to delete a TunedModel.
+            name (str):
+                Required. The resource name of the model. Format:
+                ``tunedModels/my-model-id``
+
+                This corresponds to the ``name`` field
+                on the ``request`` instance; if ``request`` is provided, this
+                should not be set.
+            retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                sent along with the request as metadata. Normally, each value must be of type `str`,
+                but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                be of type `bytes`.
+        """
+        # Create or coerce a protobuf request object.
+        # - Quick check: If we got a request object, we should *not* have
+        #   gotten any keyword arguments that map to the request.
+        has_flattened_params = any([name])
+        if request is not None and has_flattened_params:
+            raise ValueError(
+                "If the `request` argument is set, then none of "
+                "the individual field arguments should be set."
+            )
+
+        # - Use the request object if provided (there's no risk of modifying the input as
+        #   there are no flattened fields), or create one.
+        if not isinstance(request, model_service.DeleteTunedModelRequest):
+            request = model_service.DeleteTunedModelRequest(request)
+            # If we have keyword arguments corresponding to fields on the
+            # request, apply these.
+            if name is not None:
+                request.name = name
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = self._transport._wrapped_methods[self._transport.delete_tuned_model]
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Validate the universe domain.
+        self._validate_universe_domain()
+
+        # Send the request.
+        rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    def __enter__(self) -> "ModelServiceClient":
+        return self
+
+    def __exit__(self, type, value, traceback):
+        """Releases underlying transport's resources.
+
+        .. warning::
+            ONLY use as a context manager if the transport is NOT shared
+            with other clients! Exiting the with block will CLOSE the transport
+            and may cause errors in other clients!
+        """
+        self.transport.close()
+
+
+DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
+    gapic_version=package_version.__version__
+)
+
+
+__all__ = ("ModelServiceClient",)

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/services/model_service/pagers.py

@@ -0,0 +1,353 @@
+# -*- coding: utf-8 -*-
+# 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 (
+    Any,
+    AsyncIterator,
+    Awaitable,
+    Callable,
+    Iterator,
+    Optional,
+    Sequence,
+    Tuple,
+    Union,
+)
+
+from google.api_core import gapic_v1
+from google.api_core import retry as retries
+from google.api_core import retry_async as retries_async
+
+try:
+    OptionalRetry = Union[retries.Retry, gapic_v1.method._MethodDefault, None]
+    OptionalAsyncRetry = Union[
+        retries_async.AsyncRetry, gapic_v1.method._MethodDefault, None
+    ]
+except AttributeError:  # pragma: NO COVER
+    OptionalRetry = Union[retries.Retry, object, None]  # type: ignore
+    OptionalAsyncRetry = Union[retries_async.AsyncRetry, object, None]  # type: ignore
+
+from google.ai.generativelanguage_v1beta3.types import model, model_service, tuned_model
+
+
+class ListModelsPager:
+    """A pager for iterating through ``list_models`` requests.
+
+    This class thinly wraps an initial
+    :class:`google.ai.generativelanguage_v1beta3.types.ListModelsResponse` object, and
+    provides an ``__iter__`` method to iterate through its
+    ``models`` field.
+
+    If there are more pages, the ``__iter__`` method will make additional
+    ``ListModels`` requests and continue to iterate
+    through the ``models`` field on the
+    corresponding responses.
+
+    All the usual :class:`google.ai.generativelanguage_v1beta3.types.ListModelsResponse`
+    attributes are available on the pager. If multiple requests are made, only
+    the most recent response is retained, and thus used for attribute lookup.
+    """
+
+    def __init__(
+        self,
+        method: Callable[..., model_service.ListModelsResponse],
+        request: model_service.ListModelsRequest,
+        response: model_service.ListModelsResponse,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]] = ()
+    ):
+        """Instantiate the pager.
+
+        Args:
+            method (Callable): The method that was originally called, and
+                which instantiated this pager.
+            request (google.ai.generativelanguage_v1beta3.types.ListModelsRequest):
+                The initial request object.
+            response (google.ai.generativelanguage_v1beta3.types.ListModelsResponse):
+                The initial response object.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                sent along with the request as metadata. Normally, each value must be of type `str`,
+                but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                be of type `bytes`.
+        """
+        self._method = method
+        self._request = model_service.ListModelsRequest(request)
+        self._response = response
+        self._retry = retry
+        self._timeout = timeout
+        self._metadata = metadata
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._response, name)
+
+    @property
+    def pages(self) -> Iterator[model_service.ListModelsResponse]:
+        yield self._response
+        while self._response.next_page_token:
+            self._request.page_token = self._response.next_page_token
+            self._response = self._method(
+                self._request,
+                retry=self._retry,
+                timeout=self._timeout,
+                metadata=self._metadata,
+            )
+            yield self._response
+
+    def __iter__(self) -> Iterator[model.Model]:
+        for page in self.pages:
+            yield from page.models
+
+    def __repr__(self) -> str:
+        return "{0}<{1!r}>".format(self.__class__.__name__, self._response)
+
+
+class ListModelsAsyncPager:
+    """A pager for iterating through ``list_models`` requests.
+
+    This class thinly wraps an initial
+    :class:`google.ai.generativelanguage_v1beta3.types.ListModelsResponse` object, and
+    provides an ``__aiter__`` method to iterate through its
+    ``models`` field.
+
+    If there are more pages, the ``__aiter__`` method will make additional
+    ``ListModels`` requests and continue to iterate
+    through the ``models`` field on the
+    corresponding responses.
+
+    All the usual :class:`google.ai.generativelanguage_v1beta3.types.ListModelsResponse`
+    attributes are available on the pager. If multiple requests are made, only
+    the most recent response is retained, and thus used for attribute lookup.
+    """
+
+    def __init__(
+        self,
+        method: Callable[..., Awaitable[model_service.ListModelsResponse]],
+        request: model_service.ListModelsRequest,
+        response: model_service.ListModelsResponse,
+        *,
+        retry: OptionalAsyncRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]] = ()
+    ):
+        """Instantiates the pager.
+
+        Args:
+            method (Callable): The method that was originally called, and
+                which instantiated this pager.
+            request (google.ai.generativelanguage_v1beta3.types.ListModelsRequest):
+                The initial request object.
+            response (google.ai.generativelanguage_v1beta3.types.ListModelsResponse):
+                The initial response object.
+            retry (google.api_core.retry.AsyncRetry): Designation of what errors,
+                if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                sent along with the request as metadata. Normally, each value must be of type `str`,
+                but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                be of type `bytes`.
+        """
+        self._method = method
+        self._request = model_service.ListModelsRequest(request)
+        self._response = response
+        self._retry = retry
+        self._timeout = timeout
+        self._metadata = metadata
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._response, name)
+
+    @property
+    async def pages(self) -> AsyncIterator[model_service.ListModelsResponse]:
+        yield self._response
+        while self._response.next_page_token:
+            self._request.page_token = self._response.next_page_token
+            self._response = await self._method(
+                self._request,
+                retry=self._retry,
+                timeout=self._timeout,
+                metadata=self._metadata,
+            )
+            yield self._response
+
+    def __aiter__(self) -> AsyncIterator[model.Model]:
+        async def async_generator():
+            async for page in self.pages:
+                for response in page.models:
+                    yield response
+
+        return async_generator()
+
+    def __repr__(self) -> str:
+        return "{0}<{1!r}>".format(self.__class__.__name__, self._response)
+
+
+class ListTunedModelsPager:
+    """A pager for iterating through ``list_tuned_models`` requests.
+
+    This class thinly wraps an initial
+    :class:`google.ai.generativelanguage_v1beta3.types.ListTunedModelsResponse` object, and
+    provides an ``__iter__`` method to iterate through its
+    ``tuned_models`` field.
+
+    If there are more pages, the ``__iter__`` method will make additional
+    ``ListTunedModels`` requests and continue to iterate
+    through the ``tuned_models`` field on the
+    corresponding responses.
+
+    All the usual :class:`google.ai.generativelanguage_v1beta3.types.ListTunedModelsResponse`
+    attributes are available on the pager. If multiple requests are made, only
+    the most recent response is retained, and thus used for attribute lookup.
+    """
+
+    def __init__(
+        self,
+        method: Callable[..., model_service.ListTunedModelsResponse],
+        request: model_service.ListTunedModelsRequest,
+        response: model_service.ListTunedModelsResponse,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]] = ()
+    ):
+        """Instantiate the pager.
+
+        Args:
+            method (Callable): The method that was originally called, and
+                which instantiated this pager.
+            request (google.ai.generativelanguage_v1beta3.types.ListTunedModelsRequest):
+                The initial request object.
+            response (google.ai.generativelanguage_v1beta3.types.ListTunedModelsResponse):
+                The initial response object.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                sent along with the request as metadata. Normally, each value must be of type `str`,
+                but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                be of type `bytes`.
+        """
+        self._method = method
+        self._request = model_service.ListTunedModelsRequest(request)
+        self._response = response
+        self._retry = retry
+        self._timeout = timeout
+        self._metadata = metadata
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._response, name)
+
+    @property
+    def pages(self) -> Iterator[model_service.ListTunedModelsResponse]:
+        yield self._response
+        while self._response.next_page_token:
+            self._request.page_token = self._response.next_page_token
+            self._response = self._method(
+                self._request,
+                retry=self._retry,
+                timeout=self._timeout,
+                metadata=self._metadata,
+            )
+            yield self._response
+
+    def __iter__(self) -> Iterator[tuned_model.TunedModel]:
+        for page in self.pages:
+            yield from page.tuned_models
+
+    def __repr__(self) -> str:
+        return "{0}<{1!r}>".format(self.__class__.__name__, self._response)
+
+
+class ListTunedModelsAsyncPager:
+    """A pager for iterating through ``list_tuned_models`` requests.
+
+    This class thinly wraps an initial
+    :class:`google.ai.generativelanguage_v1beta3.types.ListTunedModelsResponse` object, and
+    provides an ``__aiter__`` method to iterate through its
+    ``tuned_models`` field.
+
+    If there are more pages, the ``__aiter__`` method will make additional
+    ``ListTunedModels`` requests and continue to iterate
+    through the ``tuned_models`` field on the
+    corresponding responses.
+
+    All the usual :class:`google.ai.generativelanguage_v1beta3.types.ListTunedModelsResponse`
+    attributes are available on the pager. If multiple requests are made, only
+    the most recent response is retained, and thus used for attribute lookup.
+    """
+
+    def __init__(
+        self,
+        method: Callable[..., Awaitable[model_service.ListTunedModelsResponse]],
+        request: model_service.ListTunedModelsRequest,
+        response: model_service.ListTunedModelsResponse,
+        *,
+        retry: OptionalAsyncRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]] = ()
+    ):
+        """Instantiates the pager.
+
+        Args:
+            method (Callable): The method that was originally called, and
+                which instantiated this pager.
+            request (google.ai.generativelanguage_v1beta3.types.ListTunedModelsRequest):
+                The initial request object.
+            response (google.ai.generativelanguage_v1beta3.types.ListTunedModelsResponse):
+                The initial response object.
+            retry (google.api_core.retry.AsyncRetry): Designation of what errors,
+                if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                sent along with the request as metadata. Normally, each value must be of type `str`,
+                but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                be of type `bytes`.
+        """
+        self._method = method
+        self._request = model_service.ListTunedModelsRequest(request)
+        self._response = response
+        self._retry = retry
+        self._timeout = timeout
+        self._metadata = metadata
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._response, name)
+
+    @property
+    async def pages(self) -> AsyncIterator[model_service.ListTunedModelsResponse]:
+        yield self._response
+        while self._response.next_page_token:
+            self._request.page_token = self._response.next_page_token
+            self._response = await self._method(
+                self._request,
+                retry=self._retry,
+                timeout=self._timeout,
+                metadata=self._metadata,
+            )
+            yield self._response
+
+    def __aiter__(self) -> AsyncIterator[tuned_model.TunedModel]:
+        async def async_generator():
+            async for page in self.pages:
+                for response in page.tuned_models:
+                    yield response
+
+        return async_generator()
+
+    def __repr__(self) -> str:
+        return "{0}<{1!r}>".format(self.__class__.__name__, self._response)

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/services/model_service/transports/__init__.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+# 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 collections import OrderedDict
+from typing import Dict, Type
+
+from .base import ModelServiceTransport
+from .grpc import ModelServiceGrpcTransport
+from .grpc_asyncio import ModelServiceGrpcAsyncIOTransport
+from .rest import ModelServiceRestInterceptor, ModelServiceRestTransport
+
+# Compile a registry of transports.
+_transport_registry = OrderedDict()  # type: Dict[str, Type[ModelServiceTransport]]
+_transport_registry["grpc"] = ModelServiceGrpcTransport
+_transport_registry["grpc_asyncio"] = ModelServiceGrpcAsyncIOTransport
+_transport_registry["rest"] = ModelServiceRestTransport
+
+__all__ = (
+    "ModelServiceTransport",
+    "ModelServiceGrpcTransport",
+    "ModelServiceGrpcAsyncIOTransport",
+    "ModelServiceRestTransport",
+    "ModelServiceRestInterceptor",
+)

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/services/model_service/transports/base.py

@@ -0,0 +1,259 @@
+# -*- coding: utf-8 -*-
+# 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 abc
+from typing import Awaitable, Callable, Dict, Optional, Sequence, Union
+
+import google.api_core
+from google.api_core import exceptions as core_exceptions
+from google.api_core import gapic_v1, operations_v1
+from google.api_core import retry as retries
+import google.auth  # type: ignore
+from google.auth import credentials as ga_credentials  # type: ignore
+from google.longrunning import operations_pb2  # type: ignore
+from google.oauth2 import service_account  # type: ignore
+from google.protobuf import empty_pb2  # type: ignore
+
+from google.ai.generativelanguage_v1beta3 import gapic_version as package_version
+from google.ai.generativelanguage_v1beta3.types import tuned_model as gag_tuned_model
+from google.ai.generativelanguage_v1beta3.types import model, model_service
+from google.ai.generativelanguage_v1beta3.types import tuned_model
+
+DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
+    gapic_version=package_version.__version__
+)
+
+
+class ModelServiceTransport(abc.ABC):
+    """Abstract transport class for ModelService."""
+
+    AUTH_SCOPES = ()
+
+    DEFAULT_HOST: str = "generativelanguage.googleapis.com"
+
+    def __init__(
+        self,
+        *,
+        host: str = DEFAULT_HOST,
+        credentials: Optional[ga_credentials.Credentials] = None,
+        credentials_file: Optional[str] = None,
+        scopes: Optional[Sequence[str]] = None,
+        quota_project_id: Optional[str] = None,
+        client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
+        always_use_jwt_access: Optional[bool] = False,
+        api_audience: Optional[str] = None,
+        **kwargs,
+    ) -> None:
+        """Instantiate the transport.
+
+        Args:
+            host (Optional[str]):
+                 The hostname to connect to (default: 'generativelanguage.googleapis.com').
+            credentials (Optional[google.auth.credentials.Credentials]): The
+                authorization credentials to attach to requests. These
+                credentials identify the application to the service; if none
+                are specified, the client will attempt to ascertain the
+                credentials from the environment.
+            credentials_file (Optional[str]): A file with credentials that can
+                be loaded with :func:`google.auth.load_credentials_from_file`.
+                This argument is mutually exclusive with credentials.
+            scopes (Optional[Sequence[str]]): A list of scopes.
+            quota_project_id (Optional[str]): An optional project to use for billing
+                and quota.
+            client_info (google.api_core.gapic_v1.client_info.ClientInfo):
+                The client info used to send a user-agent string along with
+                API requests. If ``None``, then default info will be used.
+                Generally, you only need to set this if you're developing
+                your own client library.
+            always_use_jwt_access (Optional[bool]): Whether self signed JWT should
+                be used for service account credentials.
+        """
+
+        scopes_kwargs = {"scopes": scopes, "default_scopes": self.AUTH_SCOPES}
+
+        # Save the scopes.
+        self._scopes = scopes
+        if not hasattr(self, "_ignore_credentials"):
+            self._ignore_credentials: bool = False
+
+        # If no credentials are provided, then determine the appropriate
+        # defaults.
+        if credentials and credentials_file:
+            raise core_exceptions.DuplicateCredentialArgs(
+                "'credentials_file' and 'credentials' are mutually exclusive"
+            )
+
+        if credentials_file is not None:
+            credentials, _ = google.auth.load_credentials_from_file(
+                credentials_file, **scopes_kwargs, quota_project_id=quota_project_id
+            )
+        elif credentials is None and not self._ignore_credentials:
+            credentials, _ = google.auth.default(
+                **scopes_kwargs, quota_project_id=quota_project_id
+            )
+            # Don't apply audience if the credentials file passed from user.
+            if hasattr(credentials, "with_gdch_audience"):
+                credentials = credentials.with_gdch_audience(
+                    api_audience if api_audience else host
+                )
+
+        # If the credentials are service account credentials, then always try to use self signed JWT.
+        if (
+            always_use_jwt_access
+            and isinstance(credentials, service_account.Credentials)
+            and hasattr(service_account.Credentials, "with_always_use_jwt_access")
+        ):
+            credentials = credentials.with_always_use_jwt_access(True)
+
+        # Save the credentials.
+        self._credentials = credentials
+
+        # Save the hostname. Default to port 443 (HTTPS) if none is specified.
+        if ":" not in host:
+            host += ":443"
+        self._host = host
+
+    @property
+    def host(self):
+        return self._host
+
+    def _prep_wrapped_messages(self, client_info):
+        # Precompute the wrapped methods.
+        self._wrapped_methods = {
+            self.get_model: gapic_v1.method.wrap_method(
+                self.get_model,
+                default_timeout=None,
+                client_info=client_info,
+            ),
+            self.list_models: gapic_v1.method.wrap_method(
+                self.list_models,
+                default_timeout=None,
+                client_info=client_info,
+            ),
+            self.get_tuned_model: gapic_v1.method.wrap_method(
+                self.get_tuned_model,
+                default_timeout=None,
+                client_info=client_info,
+            ),
+            self.list_tuned_models: gapic_v1.method.wrap_method(
+                self.list_tuned_models,
+                default_timeout=None,
+                client_info=client_info,
+            ),
+            self.create_tuned_model: gapic_v1.method.wrap_method(
+                self.create_tuned_model,
+                default_timeout=None,
+                client_info=client_info,
+            ),
+            self.update_tuned_model: gapic_v1.method.wrap_method(
+                self.update_tuned_model,
+                default_timeout=None,
+                client_info=client_info,
+            ),
+            self.delete_tuned_model: gapic_v1.method.wrap_method(
+                self.delete_tuned_model,
+                default_timeout=None,
+                client_info=client_info,
+            ),
+        }
+
+    def close(self):
+        """Closes resources associated with the transport.
+
+        .. warning::
+             Only call this method if the transport is NOT shared
+             with other clients - this may cause errors in other clients!
+        """
+        raise NotImplementedError()
+
+    @property
+    def operations_client(self):
+        """Return the client designed to process long-running operations."""
+        raise NotImplementedError()
+
+    @property
+    def get_model(
+        self,
+    ) -> Callable[
+        [model_service.GetModelRequest], Union[model.Model, Awaitable[model.Model]]
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def list_models(
+        self,
+    ) -> Callable[
+        [model_service.ListModelsRequest],
+        Union[
+            model_service.ListModelsResponse,
+            Awaitable[model_service.ListModelsResponse],
+        ],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def get_tuned_model(
+        self,
+    ) -> Callable[
+        [model_service.GetTunedModelRequest],
+        Union[tuned_model.TunedModel, Awaitable[tuned_model.TunedModel]],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def list_tuned_models(
+        self,
+    ) -> Callable[
+        [model_service.ListTunedModelsRequest],
+        Union[
+            model_service.ListTunedModelsResponse,
+            Awaitable[model_service.ListTunedModelsResponse],
+        ],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def create_tuned_model(
+        self,
+    ) -> Callable[
+        [model_service.CreateTunedModelRequest],
+        Union[operations_pb2.Operation, Awaitable[operations_pb2.Operation]],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def update_tuned_model(
+        self,
+    ) -> Callable[
+        [model_service.UpdateTunedModelRequest],
+        Union[gag_tuned_model.TunedModel, Awaitable[gag_tuned_model.TunedModel]],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def delete_tuned_model(
+        self,
+    ) -> Callable[
+        [model_service.DeleteTunedModelRequest],
+        Union[empty_pb2.Empty, Awaitable[empty_pb2.Empty]],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def kind(self) -> str:
+        raise NotImplementedError()
+
+
+__all__ = ("ModelServiceTransport",)

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/services/model_service/transports/grpc.py

@@ -0,0 +1,540 @@
+# -*- coding: utf-8 -*-
+# 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 json
+import logging as std_logging
+import pickle
+from typing import Callable, Dict, Optional, Sequence, Tuple, Union
+import warnings
+
+from google.api_core import gapic_v1, grpc_helpers, operations_v1
+import google.auth  # type: ignore
+from google.auth import credentials as ga_credentials  # type: ignore
+from google.auth.transport.grpc import SslCredentials  # type: ignore
+from google.longrunning import operations_pb2  # type: ignore
+from google.protobuf import empty_pb2  # type: ignore
+from google.protobuf.json_format import MessageToJson
+import google.protobuf.message
+import grpc  # type: ignore
+import proto  # type: ignore
+
+from google.ai.generativelanguage_v1beta3.types import tuned_model as gag_tuned_model
+from google.ai.generativelanguage_v1beta3.types import model, model_service
+from google.ai.generativelanguage_v1beta3.types import tuned_model
+
+from .base import DEFAULT_CLIENT_INFO, ModelServiceTransport
+
+try:
+    from google.api_core import client_logging  # type: ignore
+
+    CLIENT_LOGGING_SUPPORTED = True  # pragma: NO COVER
+except ImportError:  # pragma: NO COVER
+    CLIENT_LOGGING_SUPPORTED = False
+
+_LOGGER = std_logging.getLogger(__name__)
+
+
+class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor):  # pragma: NO COVER
+    def intercept_unary_unary(self, continuation, client_call_details, request):
+        logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+            std_logging.DEBUG
+        )
+        if logging_enabled:  # pragma: NO COVER
+            request_metadata = client_call_details.metadata
+            if isinstance(request, proto.Message):
+                request_payload = type(request).to_json(request)
+            elif isinstance(request, google.protobuf.message.Message):
+                request_payload = MessageToJson(request)
+            else:
+                request_payload = f"{type(request).__name__}: {pickle.dumps(request)}"
+
+            request_metadata = {
+                key: value.decode("utf-8") if isinstance(value, bytes) else value
+                for key, value in request_metadata
+            }
+            grpc_request = {
+                "payload": request_payload,
+                "requestMethod": "grpc",
+                "metadata": dict(request_metadata),
+            }
+            _LOGGER.debug(
+                f"Sending request for {client_call_details.method}",
+                extra={
+                    "serviceName": "google.ai.generativelanguage.v1beta3.ModelService",
+                    "rpcName": client_call_details.method,
+                    "request": grpc_request,
+                    "metadata": grpc_request["metadata"],
+                },
+            )
+
+        response = continuation(client_call_details, request)
+        if logging_enabled:  # pragma: NO COVER
+            response_metadata = response.trailing_metadata()
+            # Convert gRPC metadata `<class 'grpc.aio._metadata.Metadata'>` to list of tuples
+            metadata = (
+                dict([(k, str(v)) for k, v in response_metadata])
+                if response_metadata
+                else None
+            )
+            result = response.result()
+            if isinstance(result, proto.Message):
+                response_payload = type(result).to_json(result)
+            elif isinstance(result, google.protobuf.message.Message):
+                response_payload = MessageToJson(result)
+            else:
+                response_payload = f"{type(result).__name__}: {pickle.dumps(result)}"
+            grpc_response = {
+                "payload": response_payload,
+                "metadata": metadata,
+                "status": "OK",
+            }
+            _LOGGER.debug(
+                f"Received response for {client_call_details.method}.",
+                extra={
+                    "serviceName": "google.ai.generativelanguage.v1beta3.ModelService",
+                    "rpcName": client_call_details.method,
+                    "response": grpc_response,
+                    "metadata": grpc_response["metadata"],
+                },
+            )
+        return response
+
+
+class ModelServiceGrpcTransport(ModelServiceTransport):
+    """gRPC backend transport for ModelService.
+
+    Provides methods for getting metadata information about
+    Generative Models.
+
+    This class defines the same methods as the primary client, so the
+    primary client can load the underlying transport implementation
+    and call it.
+
+    It sends protocol buffers over the wire using gRPC (which is built on
+    top of HTTP/2); the ``grpcio`` package must be installed.
+    """
+
+    _stubs: Dict[str, Callable]
+
+    def __init__(
+        self,
+        *,
+        host: str = "generativelanguage.googleapis.com",
+        credentials: Optional[ga_credentials.Credentials] = None,
+        credentials_file: Optional[str] = None,
+        scopes: Optional[Sequence[str]] = None,
+        channel: Optional[Union[grpc.Channel, Callable[..., grpc.Channel]]] = None,
+        api_mtls_endpoint: Optional[str] = None,
+        client_cert_source: Optional[Callable[[], Tuple[bytes, bytes]]] = None,
+        ssl_channel_credentials: Optional[grpc.ChannelCredentials] = None,
+        client_cert_source_for_mtls: Optional[Callable[[], Tuple[bytes, bytes]]] = None,
+        quota_project_id: Optional[str] = None,
+        client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
+        always_use_jwt_access: Optional[bool] = False,
+        api_audience: Optional[str] = None,
+    ) -> None:
+        """Instantiate the transport.
+
+        Args:
+            host (Optional[str]):
+                 The hostname to connect to (default: 'generativelanguage.googleapis.com').
+            credentials (Optional[google.auth.credentials.Credentials]): The
+                authorization credentials to attach to requests. These
+                credentials identify the application to the service; if none
+                are specified, the client will attempt to ascertain the
+                credentials from the environment.
+                This argument is ignored if a ``channel`` instance is provided.
+            credentials_file (Optional[str]): A file with credentials that can
+                be loaded with :func:`google.auth.load_credentials_from_file`.
+                This argument is ignored if a ``channel`` instance is provided.
+            scopes (Optional(Sequence[str])): A list of scopes. This argument is
+                ignored if a ``channel`` instance is provided.
+            channel (Optional[Union[grpc.Channel, Callable[..., grpc.Channel]]]):
+                A ``Channel`` instance through which to make calls, or a Callable
+                that constructs and returns one. If set to None, ``self.create_channel``
+                is used to create the channel. If a Callable is given, it will be called
+                with the same arguments as used in ``self.create_channel``.
+            api_mtls_endpoint (Optional[str]): Deprecated. The mutual TLS endpoint.
+                If provided, it overrides the ``host`` argument and tries to create
+                a mutual TLS channel with client SSL credentials from
+                ``client_cert_source`` or application default SSL credentials.
+            client_cert_source (Optional[Callable[[], Tuple[bytes, bytes]]]):
+                Deprecated. A callback to provide client SSL certificate bytes and
+                private key bytes, both in PEM format. It is ignored if
+                ``api_mtls_endpoint`` is None.
+            ssl_channel_credentials (grpc.ChannelCredentials): SSL credentials
+                for the grpc channel. It is ignored if a ``channel`` instance is provided.
+            client_cert_source_for_mtls (Optional[Callable[[], Tuple[bytes, bytes]]]):
+                A callback to provide client certificate bytes and private key bytes,
+                both in PEM format. It is used to configure a mutual TLS channel. It is
+                ignored if a ``channel`` instance or ``ssl_channel_credentials`` is provided.
+            quota_project_id (Optional[str]): An optional project to use for billing
+                and quota.
+            client_info (google.api_core.gapic_v1.client_info.ClientInfo):
+                The client info used to send a user-agent string along with
+                API requests. If ``None``, then default info will be used.
+                Generally, you only need to set this if you're developing
+                your own client library.
+            always_use_jwt_access (Optional[bool]): Whether self signed JWT should
+                be used for service account credentials.
+
+        Raises:
+          google.auth.exceptions.MutualTLSChannelError: If mutual TLS transport
+              creation failed for any reason.
+          google.api_core.exceptions.DuplicateCredentialArgs: If both ``credentials``
+              and ``credentials_file`` are passed.
+        """
+        self._grpc_channel = None
+        self._ssl_channel_credentials = ssl_channel_credentials
+        self._stubs: Dict[str, Callable] = {}
+        self._operations_client: Optional[operations_v1.OperationsClient] = None
+
+        if api_mtls_endpoint:
+            warnings.warn("api_mtls_endpoint is deprecated", DeprecationWarning)
+        if client_cert_source:
+            warnings.warn("client_cert_source is deprecated", DeprecationWarning)
+
+        if isinstance(channel, grpc.Channel):
+            # Ignore credentials if a channel was passed.
+            credentials = None
+            self._ignore_credentials = True
+            # If a channel was explicitly provided, set it.
+            self._grpc_channel = channel
+            self._ssl_channel_credentials = None
+
+        else:
+            if api_mtls_endpoint:
+                host = api_mtls_endpoint
+
+                # Create SSL credentials with client_cert_source or application
+                # default SSL credentials.
+                if client_cert_source:
+                    cert, key = client_cert_source()
+                    self._ssl_channel_credentials = grpc.ssl_channel_credentials(
+                        certificate_chain=cert, private_key=key
+                    )
+                else:
+                    self._ssl_channel_credentials = SslCredentials().ssl_credentials
+
+            else:
+                if client_cert_source_for_mtls and not ssl_channel_credentials:
+                    cert, key = client_cert_source_for_mtls()
+                    self._ssl_channel_credentials = grpc.ssl_channel_credentials(
+                        certificate_chain=cert, private_key=key
+                    )
+
+        # The base transport sets the host, credentials and scopes
+        super().__init__(
+            host=host,
+            credentials=credentials,
+            credentials_file=credentials_file,
+            scopes=scopes,
+            quota_project_id=quota_project_id,
+            client_info=client_info,
+            always_use_jwt_access=always_use_jwt_access,
+            api_audience=api_audience,
+        )
+
+        if not self._grpc_channel:
+            # initialize with the provided callable or the default channel
+            channel_init = channel or type(self).create_channel
+            self._grpc_channel = channel_init(
+                self._host,
+                # use the credentials which are saved
+                credentials=self._credentials,
+                # Set ``credentials_file`` to ``None`` here as
+                # the credentials that we saved earlier should be used.
+                credentials_file=None,
+                scopes=self._scopes,
+                ssl_credentials=self._ssl_channel_credentials,
+                quota_project_id=quota_project_id,
+                options=[
+                    ("grpc.max_send_message_length", -1),
+                    ("grpc.max_receive_message_length", -1),
+                ],
+            )
+
+        self._interceptor = _LoggingClientInterceptor()
+        self._logged_channel = grpc.intercept_channel(
+            self._grpc_channel, self._interceptor
+        )
+
+        # Wrap messages. This must be done after self._logged_channel exists
+        self._prep_wrapped_messages(client_info)
+
+    @classmethod
+    def create_channel(
+        cls,
+        host: str = "generativelanguage.googleapis.com",
+        credentials: Optional[ga_credentials.Credentials] = None,
+        credentials_file: Optional[str] = None,
+        scopes: Optional[Sequence[str]] = None,
+        quota_project_id: Optional[str] = None,
+        **kwargs,
+    ) -> grpc.Channel:
+        """Create and return a gRPC channel object.
+        Args:
+            host (Optional[str]): The host for the channel to use.
+            credentials (Optional[~.Credentials]): The
+                authorization credentials to attach to requests. These
+                credentials identify this application to the service. If
+                none are specified, the client will attempt to ascertain
+                the credentials from the environment.
+            credentials_file (Optional[str]): A file with credentials that can
+                be loaded with :func:`google.auth.load_credentials_from_file`.
+                This argument is mutually exclusive with credentials.
+            scopes (Optional[Sequence[str]]): A optional list of scopes needed for this
+                service. These are only used when credentials are not specified and
+                are passed to :func:`google.auth.default`.
+            quota_project_id (Optional[str]): An optional project to use for billing
+                and quota.
+            kwargs (Optional[dict]): Keyword arguments, which are passed to the
+                channel creation.
+        Returns:
+            grpc.Channel: A gRPC channel object.
+
+        Raises:
+            google.api_core.exceptions.DuplicateCredentialArgs: If both ``credentials``
+              and ``credentials_file`` are passed.
+        """
+
+        return grpc_helpers.create_channel(
+            host,
+            credentials=credentials,
+            credentials_file=credentials_file,
+            quota_project_id=quota_project_id,
+            default_scopes=cls.AUTH_SCOPES,
+            scopes=scopes,
+            default_host=cls.DEFAULT_HOST,
+            **kwargs,
+        )
+
+    @property
+    def grpc_channel(self) -> grpc.Channel:
+        """Return the channel designed to connect to this service."""
+        return self._grpc_channel
+
+    @property
+    def operations_client(self) -> operations_v1.OperationsClient:
+        """Create the client designed to process long-running operations.
+
+        This property caches on the instance; repeated calls return the same
+        client.
+        """
+        # Quick check: Only create a new client if we do not already have one.
+        if self._operations_client is None:
+            self._operations_client = operations_v1.OperationsClient(
+                self._logged_channel
+            )
+
+        # Return the client from cache.
+        return self._operations_client
+
+    @property
+    def get_model(self) -> Callable[[model_service.GetModelRequest], model.Model]:
+        r"""Return a callable for the get model method over gRPC.
+
+        Gets information about a specific Model.
+
+        Returns:
+            Callable[[~.GetModelRequest],
+                    ~.Model]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "get_model" not in self._stubs:
+            self._stubs["get_model"] = self._logged_channel.unary_unary(
+                "/google.ai.generativelanguage.v1beta3.ModelService/GetModel",
+                request_serializer=model_service.GetModelRequest.serialize,
+                response_deserializer=model.Model.deserialize,
+            )
+        return self._stubs["get_model"]
+
+    @property
+    def list_models(
+        self,
+    ) -> Callable[[model_service.ListModelsRequest], model_service.ListModelsResponse]:
+        r"""Return a callable for the list models method over gRPC.
+
+        Lists models available through the API.
+
+        Returns:
+            Callable[[~.ListModelsRequest],
+                    ~.ListModelsResponse]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "list_models" not in self._stubs:
+            self._stubs["list_models"] = self._logged_channel.unary_unary(
+                "/google.ai.generativelanguage.v1beta3.ModelService/ListModels",
+                request_serializer=model_service.ListModelsRequest.serialize,
+                response_deserializer=model_service.ListModelsResponse.deserialize,
+            )
+        return self._stubs["list_models"]
+
+    @property
+    def get_tuned_model(
+        self,
+    ) -> Callable[[model_service.GetTunedModelRequest], tuned_model.TunedModel]:
+        r"""Return a callable for the get tuned model method over gRPC.
+
+        Gets information about a specific TunedModel.
+
+        Returns:
+            Callable[[~.GetTunedModelRequest],
+                    ~.TunedModel]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "get_tuned_model" not in self._stubs:
+            self._stubs["get_tuned_model"] = self._logged_channel.unary_unary(
+                "/google.ai.generativelanguage.v1beta3.ModelService/GetTunedModel",
+                request_serializer=model_service.GetTunedModelRequest.serialize,
+                response_deserializer=tuned_model.TunedModel.deserialize,
+            )
+        return self._stubs["get_tuned_model"]
+
+    @property
+    def list_tuned_models(
+        self,
+    ) -> Callable[
+        [model_service.ListTunedModelsRequest], model_service.ListTunedModelsResponse
+    ]:
+        r"""Return a callable for the list tuned models method over gRPC.
+
+        Lists tuned models owned by the user.
+
+        Returns:
+            Callable[[~.ListTunedModelsRequest],
+                    ~.ListTunedModelsResponse]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "list_tuned_models" not in self._stubs:
+            self._stubs["list_tuned_models"] = self._logged_channel.unary_unary(
+                "/google.ai.generativelanguage.v1beta3.ModelService/ListTunedModels",
+                request_serializer=model_service.ListTunedModelsRequest.serialize,
+                response_deserializer=model_service.ListTunedModelsResponse.deserialize,
+            )
+        return self._stubs["list_tuned_models"]
+
+    @property
+    def create_tuned_model(
+        self,
+    ) -> Callable[[model_service.CreateTunedModelRequest], operations_pb2.Operation]:
+        r"""Return a callable for the create tuned model method over gRPC.
+
+        Creates a tuned model. Intermediate tuning progress (if any) is
+        accessed through the [google.longrunning.Operations] service.
+
+        Status and results can be accessed through the Operations
+        service. Example: GET
+        /v1/tunedModels/az2mb0bpw6i/operations/000-111-222
+
+        Returns:
+            Callable[[~.CreateTunedModelRequest],
+                    ~.Operation]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "create_tuned_model" not in self._stubs:
+            self._stubs["create_tuned_model"] = self._logged_channel.unary_unary(
+                "/google.ai.generativelanguage.v1beta3.ModelService/CreateTunedModel",
+                request_serializer=model_service.CreateTunedModelRequest.serialize,
+                response_deserializer=operations_pb2.Operation.FromString,
+            )
+        return self._stubs["create_tuned_model"]
+
+    @property
+    def update_tuned_model(
+        self,
+    ) -> Callable[[model_service.UpdateTunedModelRequest], gag_tuned_model.TunedModel]:
+        r"""Return a callable for the update tuned model method over gRPC.
+
+        Updates a tuned model.
+
+        Returns:
+            Callable[[~.UpdateTunedModelRequest],
+                    ~.TunedModel]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "update_tuned_model" not in self._stubs:
+            self._stubs["update_tuned_model"] = self._logged_channel.unary_unary(
+                "/google.ai.generativelanguage.v1beta3.ModelService/UpdateTunedModel",
+                request_serializer=model_service.UpdateTunedModelRequest.serialize,
+                response_deserializer=gag_tuned_model.TunedModel.deserialize,
+            )
+        return self._stubs["update_tuned_model"]
+
+    @property
+    def delete_tuned_model(
+        self,
+    ) -> Callable[[model_service.DeleteTunedModelRequest], empty_pb2.Empty]:
+        r"""Return a callable for the delete tuned model method over gRPC.
+
+        Deletes a tuned model.
+
+        Returns:
+            Callable[[~.DeleteTunedModelRequest],
+                    ~.Empty]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "delete_tuned_model" not in self._stubs:
+            self._stubs["delete_tuned_model"] = self._logged_channel.unary_unary(
+                "/google.ai.generativelanguage.v1beta3.ModelService/DeleteTunedModel",
+                request_serializer=model_service.DeleteTunedModelRequest.serialize,
+                response_deserializer=empty_pb2.Empty.FromString,
+            )
+        return self._stubs["delete_tuned_model"]
+
+    def close(self):
+        self._logged_channel.close()
+
+    @property
+    def kind(self) -> str:
+        return "grpc"
+
+
+__all__ = ("ModelServiceGrpcTransport",)

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/services/model_service/transports/grpc_asyncio.py

@@ -0,0 +1,603 @@
+# -*- coding: utf-8 -*-
+# 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 inspect
+import json
+import logging as std_logging
+import pickle
+from typing import Awaitable, Callable, Dict, Optional, Sequence, Tuple, Union
+import warnings
+
+from google.api_core import exceptions as core_exceptions
+from google.api_core import gapic_v1, grpc_helpers_async, operations_v1
+from google.api_core import retry_async as retries
+from google.auth import credentials as ga_credentials  # type: ignore
+from google.auth.transport.grpc import SslCredentials  # type: ignore
+from google.longrunning import operations_pb2  # type: ignore
+from google.protobuf import empty_pb2  # type: ignore
+from google.protobuf.json_format import MessageToJson
+import google.protobuf.message
+import grpc  # type: ignore
+from grpc.experimental import aio  # type: ignore
+import proto  # type: ignore
+
+from google.ai.generativelanguage_v1beta3.types import tuned_model as gag_tuned_model
+from google.ai.generativelanguage_v1beta3.types import model, model_service
+from google.ai.generativelanguage_v1beta3.types import tuned_model
+
+from .base import DEFAULT_CLIENT_INFO, ModelServiceTransport
+from .grpc import ModelServiceGrpcTransport
+
+try:
+    from google.api_core import client_logging  # type: ignore
+
+    CLIENT_LOGGING_SUPPORTED = True  # pragma: NO COVER
+except ImportError:  # pragma: NO COVER
+    CLIENT_LOGGING_SUPPORTED = False
+
+_LOGGER = std_logging.getLogger(__name__)
+
+
+class _LoggingClientAIOInterceptor(
+    grpc.aio.UnaryUnaryClientInterceptor
+):  # pragma: NO COVER
+    async def intercept_unary_unary(self, continuation, client_call_details, request):
+        logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+            std_logging.DEBUG
+        )
+        if logging_enabled:  # pragma: NO COVER
+            request_metadata = client_call_details.metadata
+            if isinstance(request, proto.Message):
+                request_payload = type(request).to_json(request)
+            elif isinstance(request, google.protobuf.message.Message):
+                request_payload = MessageToJson(request)
+            else:
+                request_payload = f"{type(request).__name__}: {pickle.dumps(request)}"
+
+            request_metadata = {
+                key: value.decode("utf-8") if isinstance(value, bytes) else value
+                for key, value in request_metadata
+            }
+            grpc_request = {
+                "payload": request_payload,
+                "requestMethod": "grpc",
+                "metadata": dict(request_metadata),
+            }
+            _LOGGER.debug(
+                f"Sending request for {client_call_details.method}",
+                extra={
+                    "serviceName": "google.ai.generativelanguage.v1beta3.ModelService",
+                    "rpcName": str(client_call_details.method),
+                    "request": grpc_request,
+                    "metadata": grpc_request["metadata"],
+                },
+            )
+        response = await continuation(client_call_details, request)
+        if logging_enabled:  # pragma: NO COVER
+            response_metadata = await response.trailing_metadata()
+            # Convert gRPC metadata `<class 'grpc.aio._metadata.Metadata'>` to list of tuples
+            metadata = (
+                dict([(k, str(v)) for k, v in response_metadata])
+                if response_metadata
+                else None
+            )
+            result = await response
+            if isinstance(result, proto.Message):
+                response_payload = type(result).to_json(result)
+            elif isinstance(result, google.protobuf.message.Message):
+                response_payload = MessageToJson(result)
+            else:
+                response_payload = f"{type(result).__name__}: {pickle.dumps(result)}"
+            grpc_response = {
+                "payload": response_payload,
+                "metadata": metadata,
+                "status": "OK",
+            }
+            _LOGGER.debug(
+                f"Received response to rpc {client_call_details.method}.",
+                extra={
+                    "serviceName": "google.ai.generativelanguage.v1beta3.ModelService",
+                    "rpcName": str(client_call_details.method),
+                    "response": grpc_response,
+                    "metadata": grpc_response["metadata"],
+                },
+            )
+        return response
+
+
+class ModelServiceGrpcAsyncIOTransport(ModelServiceTransport):
+    """gRPC AsyncIO backend transport for ModelService.
+
+    Provides methods for getting metadata information about
+    Generative Models.
+
+    This class defines the same methods as the primary client, so the
+    primary client can load the underlying transport implementation
+    and call it.
+
+    It sends protocol buffers over the wire using gRPC (which is built on
+    top of HTTP/2); the ``grpcio`` package must be installed.
+    """
+
+    _grpc_channel: aio.Channel
+    _stubs: Dict[str, Callable] = {}
+
+    @classmethod
+    def create_channel(
+        cls,
+        host: str = "generativelanguage.googleapis.com",
+        credentials: Optional[ga_credentials.Credentials] = None,
+        credentials_file: Optional[str] = None,
+        scopes: Optional[Sequence[str]] = None,
+        quota_project_id: Optional[str] = None,
+        **kwargs,
+    ) -> aio.Channel:
+        """Create and return a gRPC AsyncIO channel object.
+        Args:
+            host (Optional[str]): The host for the channel to use.
+            credentials (Optional[~.Credentials]): The
+                authorization credentials to attach to requests. These
+                credentials identify this application to the service. If
+                none are specified, the client will attempt to ascertain
+                the credentials from the environment.
+            credentials_file (Optional[str]): A file with credentials that can
+                be loaded with :func:`google.auth.load_credentials_from_file`.
+            scopes (Optional[Sequence[str]]): A optional list of scopes needed for this
+                service. These are only used when credentials are not specified and
+                are passed to :func:`google.auth.default`.
+            quota_project_id (Optional[str]): An optional project to use for billing
+                and quota.
+            kwargs (Optional[dict]): Keyword arguments, which are passed to the
+                channel creation.
+        Returns:
+            aio.Channel: A gRPC AsyncIO channel object.
+        """
+
+        return grpc_helpers_async.create_channel(
+            host,
+            credentials=credentials,
+            credentials_file=credentials_file,
+            quota_project_id=quota_project_id,
+            default_scopes=cls.AUTH_SCOPES,
+            scopes=scopes,
+            default_host=cls.DEFAULT_HOST,
+            **kwargs,
+        )
+
+    def __init__(
+        self,
+        *,
+        host: str = "generativelanguage.googleapis.com",
+        credentials: Optional[ga_credentials.Credentials] = None,
+        credentials_file: Optional[str] = None,
+        scopes: Optional[Sequence[str]] = None,
+        channel: Optional[Union[aio.Channel, Callable[..., aio.Channel]]] = None,
+        api_mtls_endpoint: Optional[str] = None,
+        client_cert_source: Optional[Callable[[], Tuple[bytes, bytes]]] = None,
+        ssl_channel_credentials: Optional[grpc.ChannelCredentials] = None,
+        client_cert_source_for_mtls: Optional[Callable[[], Tuple[bytes, bytes]]] = None,
+        quota_project_id: Optional[str] = None,
+        client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
+        always_use_jwt_access: Optional[bool] = False,
+        api_audience: Optional[str] = None,
+    ) -> None:
+        """Instantiate the transport.
+
+        Args:
+            host (Optional[str]):
+                 The hostname to connect to (default: 'generativelanguage.googleapis.com').
+            credentials (Optional[google.auth.credentials.Credentials]): The
+                authorization credentials to attach to requests. These
+                credentials identify the application to the service; if none
+                are specified, the client will attempt to ascertain the
+                credentials from the environment.
+                This argument is ignored if a ``channel`` instance is provided.
+            credentials_file (Optional[str]): A file with credentials that can
+                be loaded with :func:`google.auth.load_credentials_from_file`.
+                This argument is ignored if a ``channel`` instance is provided.
+            scopes (Optional[Sequence[str]]): A optional list of scopes needed for this
+                service. These are only used when credentials are not specified and
+                are passed to :func:`google.auth.default`.
+            channel (Optional[Union[aio.Channel, Callable[..., aio.Channel]]]):
+                A ``Channel`` instance through which to make calls, or a Callable
+                that constructs and returns one. If set to None, ``self.create_channel``
+                is used to create the channel. If a Callable is given, it will be called
+                with the same arguments as used in ``self.create_channel``.
+            api_mtls_endpoint (Optional[str]): Deprecated. The mutual TLS endpoint.
+                If provided, it overrides the ``host`` argument and tries to create
+                a mutual TLS channel with client SSL credentials from
+                ``client_cert_source`` or application default SSL credentials.
+            client_cert_source (Optional[Callable[[], Tuple[bytes, bytes]]]):
+                Deprecated. A callback to provide client SSL certificate bytes and
+                private key bytes, both in PEM format. It is ignored if
+                ``api_mtls_endpoint`` is None.
+            ssl_channel_credentials (grpc.ChannelCredentials): SSL credentials
+                for the grpc channel. It is ignored if a ``channel`` instance is provided.
+            client_cert_source_for_mtls (Optional[Callable[[], Tuple[bytes, bytes]]]):
+                A callback to provide client certificate bytes and private key bytes,
+                both in PEM format. It is used to configure a mutual TLS channel. It is
+                ignored if a ``channel`` instance or ``ssl_channel_credentials`` is provided.
+            quota_project_id (Optional[str]): An optional project to use for billing
+                and quota.
+            client_info (google.api_core.gapic_v1.client_info.ClientInfo):
+                The client info used to send a user-agent string along with
+                API requests. If ``None``, then default info will be used.
+                Generally, you only need to set this if you're developing
+                your own client library.
+            always_use_jwt_access (Optional[bool]): Whether self signed JWT should
+                be used for service account credentials.
+
+        Raises:
+            google.auth.exceptions.MutualTlsChannelError: If mutual TLS transport
+              creation failed for any reason.
+          google.api_core.exceptions.DuplicateCredentialArgs: If both ``credentials``
+              and ``credentials_file`` are passed.
+        """
+        self._grpc_channel = None
+        self._ssl_channel_credentials = ssl_channel_credentials
+        self._stubs: Dict[str, Callable] = {}
+        self._operations_client: Optional[operations_v1.OperationsAsyncClient] = None
+
+        if api_mtls_endpoint:
+            warnings.warn("api_mtls_endpoint is deprecated", DeprecationWarning)
+        if client_cert_source:
+            warnings.warn("client_cert_source is deprecated", DeprecationWarning)
+
+        if isinstance(channel, aio.Channel):
+            # Ignore credentials if a channel was passed.
+            credentials = None
+            self._ignore_credentials = True
+            # If a channel was explicitly provided, set it.
+            self._grpc_channel = channel
+            self._ssl_channel_credentials = None
+        else:
+            if api_mtls_endpoint:
+                host = api_mtls_endpoint
+
+                # Create SSL credentials with client_cert_source or application
+                # default SSL credentials.
+                if client_cert_source:
+                    cert, key = client_cert_source()
+                    self._ssl_channel_credentials = grpc.ssl_channel_credentials(
+                        certificate_chain=cert, private_key=key
+                    )
+                else:
+                    self._ssl_channel_credentials = SslCredentials().ssl_credentials
+
+            else:
+                if client_cert_source_for_mtls and not ssl_channel_credentials:
+                    cert, key = client_cert_source_for_mtls()
+                    self._ssl_channel_credentials = grpc.ssl_channel_credentials(
+                        certificate_chain=cert, private_key=key
+                    )
+
+        # The base transport sets the host, credentials and scopes
+        super().__init__(
+            host=host,
+            credentials=credentials,
+            credentials_file=credentials_file,
+            scopes=scopes,
+            quota_project_id=quota_project_id,
+            client_info=client_info,
+            always_use_jwt_access=always_use_jwt_access,
+            api_audience=api_audience,
+        )
+
+        if not self._grpc_channel:
+            # initialize with the provided callable or the default channel
+            channel_init = channel or type(self).create_channel
+            self._grpc_channel = channel_init(
+                self._host,
+                # use the credentials which are saved
+                credentials=self._credentials,
+                # Set ``credentials_file`` to ``None`` here as
+                # the credentials that we saved earlier should be used.
+                credentials_file=None,
+                scopes=self._scopes,
+                ssl_credentials=self._ssl_channel_credentials,
+                quota_project_id=quota_project_id,
+                options=[
+                    ("grpc.max_send_message_length", -1),
+                    ("grpc.max_receive_message_length", -1),
+                ],
+            )
+
+        self._interceptor = _LoggingClientAIOInterceptor()
+        self._grpc_channel._unary_unary_interceptors.append(self._interceptor)
+        self._logged_channel = self._grpc_channel
+        self._wrap_with_kind = (
+            "kind" in inspect.signature(gapic_v1.method_async.wrap_method).parameters
+        )
+        # Wrap messages. This must be done after self._logged_channel exists
+        self._prep_wrapped_messages(client_info)
+
+    @property
+    def grpc_channel(self) -> aio.Channel:
+        """Create the channel designed to connect to this service.
+
+        This property caches on the instance; repeated calls return
+        the same channel.
+        """
+        # Return the channel from cache.
+        return self._grpc_channel
+
+    @property
+    def operations_client(self) -> operations_v1.OperationsAsyncClient:
+        """Create the client designed to process long-running operations.
+
+        This property caches on the instance; repeated calls return the same
+        client.
+        """
+        # Quick check: Only create a new client if we do not already have one.
+        if self._operations_client is None:
+            self._operations_client = operations_v1.OperationsAsyncClient(
+                self._logged_channel
+            )
+
+        # Return the client from cache.
+        return self._operations_client
+
+    @property
+    def get_model(
+        self,
+    ) -> Callable[[model_service.GetModelRequest], Awaitable[model.Model]]:
+        r"""Return a callable for the get model method over gRPC.
+
+        Gets information about a specific Model.
+
+        Returns:
+            Callable[[~.GetModelRequest],
+                    Awaitable[~.Model]]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "get_model" not in self._stubs:
+            self._stubs["get_model"] = self._logged_channel.unary_unary(
+                "/google.ai.generativelanguage.v1beta3.ModelService/GetModel",
+                request_serializer=model_service.GetModelRequest.serialize,
+                response_deserializer=model.Model.deserialize,
+            )
+        return self._stubs["get_model"]
+
+    @property
+    def list_models(
+        self,
+    ) -> Callable[
+        [model_service.ListModelsRequest], Awaitable[model_service.ListModelsResponse]
+    ]:
+        r"""Return a callable for the list models method over gRPC.
+
+        Lists models available through the API.
+
+        Returns:
+            Callable[[~.ListModelsRequest],
+                    Awaitable[~.ListModelsResponse]]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "list_models" not in self._stubs:
+            self._stubs["list_models"] = self._logged_channel.unary_unary(
+                "/google.ai.generativelanguage.v1beta3.ModelService/ListModels",
+                request_serializer=model_service.ListModelsRequest.serialize,
+                response_deserializer=model_service.ListModelsResponse.deserialize,
+            )
+        return self._stubs["list_models"]
+
+    @property
+    def get_tuned_model(
+        self,
+    ) -> Callable[
+        [model_service.GetTunedModelRequest], Awaitable[tuned_model.TunedModel]
+    ]:
+        r"""Return a callable for the get tuned model method over gRPC.
+
+        Gets information about a specific TunedModel.
+
+        Returns:
+            Callable[[~.GetTunedModelRequest],
+                    Awaitable[~.TunedModel]]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "get_tuned_model" not in self._stubs:
+            self._stubs["get_tuned_model"] = self._logged_channel.unary_unary(
+                "/google.ai.generativelanguage.v1beta3.ModelService/GetTunedModel",
+                request_serializer=model_service.GetTunedModelRequest.serialize,
+                response_deserializer=tuned_model.TunedModel.deserialize,
+            )
+        return self._stubs["get_tuned_model"]
+
+    @property
+    def list_tuned_models(
+        self,
+    ) -> Callable[
+        [model_service.ListTunedModelsRequest],
+        Awaitable[model_service.ListTunedModelsResponse],
+    ]:
+        r"""Return a callable for the list tuned models method over gRPC.
+
+        Lists tuned models owned by the user.
+
+        Returns:
+            Callable[[~.ListTunedModelsRequest],
+                    Awaitable[~.ListTunedModelsResponse]]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "list_tuned_models" not in self._stubs:
+            self._stubs["list_tuned_models"] = self._logged_channel.unary_unary(
+                "/google.ai.generativelanguage.v1beta3.ModelService/ListTunedModels",
+                request_serializer=model_service.ListTunedModelsRequest.serialize,
+                response_deserializer=model_service.ListTunedModelsResponse.deserialize,
+            )
+        return self._stubs["list_tuned_models"]
+
+    @property
+    def create_tuned_model(
+        self,
+    ) -> Callable[
+        [model_service.CreateTunedModelRequest], Awaitable[operations_pb2.Operation]
+    ]:
+        r"""Return a callable for the create tuned model method over gRPC.
+
+        Creates a tuned model. Intermediate tuning progress (if any) is
+        accessed through the [google.longrunning.Operations] service.
+
+        Status and results can be accessed through the Operations
+        service. Example: GET
+        /v1/tunedModels/az2mb0bpw6i/operations/000-111-222
+
+        Returns:
+            Callable[[~.CreateTunedModelRequest],
+                    Awaitable[~.Operation]]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "create_tuned_model" not in self._stubs:
+            self._stubs["create_tuned_model"] = self._logged_channel.unary_unary(
+                "/google.ai.generativelanguage.v1beta3.ModelService/CreateTunedModel",
+                request_serializer=model_service.CreateTunedModelRequest.serialize,
+                response_deserializer=operations_pb2.Operation.FromString,
+            )
+        return self._stubs["create_tuned_model"]
+
+    @property
+    def update_tuned_model(
+        self,
+    ) -> Callable[
+        [model_service.UpdateTunedModelRequest], Awaitable[gag_tuned_model.TunedModel]
+    ]:
+        r"""Return a callable for the update tuned model method over gRPC.
+
+        Updates a tuned model.
+
+        Returns:
+            Callable[[~.UpdateTunedModelRequest],
+                    Awaitable[~.TunedModel]]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "update_tuned_model" not in self._stubs:
+            self._stubs["update_tuned_model"] = self._logged_channel.unary_unary(
+                "/google.ai.generativelanguage.v1beta3.ModelService/UpdateTunedModel",
+                request_serializer=model_service.UpdateTunedModelRequest.serialize,
+                response_deserializer=gag_tuned_model.TunedModel.deserialize,
+            )
+        return self._stubs["update_tuned_model"]
+
+    @property
+    def delete_tuned_model(
+        self,
+    ) -> Callable[[model_service.DeleteTunedModelRequest], Awaitable[empty_pb2.Empty]]:
+        r"""Return a callable for the delete tuned model method over gRPC.
+
+        Deletes a tuned model.
+
+        Returns:
+            Callable[[~.DeleteTunedModelRequest],
+                    Awaitable[~.Empty]]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "delete_tuned_model" not in self._stubs:
+            self._stubs["delete_tuned_model"] = self._logged_channel.unary_unary(
+                "/google.ai.generativelanguage.v1beta3.ModelService/DeleteTunedModel",
+                request_serializer=model_service.DeleteTunedModelRequest.serialize,
+                response_deserializer=empty_pb2.Empty.FromString,
+            )
+        return self._stubs["delete_tuned_model"]
+
+    def _prep_wrapped_messages(self, client_info):
+        """Precompute the wrapped methods, overriding the base class method to use async wrappers."""
+        self._wrapped_methods = {
+            self.get_model: self._wrap_method(
+                self.get_model,
+                default_timeout=None,
+                client_info=client_info,
+            ),
+            self.list_models: self._wrap_method(
+                self.list_models,
+                default_timeout=None,
+                client_info=client_info,
+            ),
+            self.get_tuned_model: self._wrap_method(
+                self.get_tuned_model,
+                default_timeout=None,
+                client_info=client_info,
+            ),
+            self.list_tuned_models: self._wrap_method(
+                self.list_tuned_models,
+                default_timeout=None,
+                client_info=client_info,
+            ),
+            self.create_tuned_model: self._wrap_method(
+                self.create_tuned_model,
+                default_timeout=None,
+                client_info=client_info,
+            ),
+            self.update_tuned_model: self._wrap_method(
+                self.update_tuned_model,
+                default_timeout=None,
+                client_info=client_info,
+            ),
+            self.delete_tuned_model: self._wrap_method(
+                self.delete_tuned_model,
+                default_timeout=None,
+                client_info=client_info,
+            ),
+        }
+
+    def _wrap_method(self, func, *args, **kwargs):
+        if self._wrap_with_kind:  # pragma: NO COVER
+            kwargs["kind"] = self.kind
+        return gapic_v1.method_async.wrap_method(func, *args, **kwargs)
+
+    def close(self):
+        return self._logged_channel.close()
+
+    @property
+    def kind(self) -> str:
+        return "grpc_asyncio"
+
+
+__all__ = ("ModelServiceGrpcAsyncIOTransport",)

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/services/model_service/transports/rest.py

@@ -0,0 +1,1462 @@
+# -*- coding: utf-8 -*-
+# 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 dataclasses
+import json  # type: ignore
+import logging
+from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union
+import warnings
+
+from google.api_core import gapic_v1, operations_v1, rest_helpers, rest_streaming
+from google.api_core import exceptions as core_exceptions
+from google.api_core import retry as retries
+from google.auth import credentials as ga_credentials  # type: ignore
+from google.auth.transport.requests import AuthorizedSession  # type: ignore
+from google.longrunning import operations_pb2  # type: ignore
+from google.protobuf import empty_pb2  # type: ignore
+from google.protobuf import json_format
+from requests import __version__ as requests_version
+
+from google.ai.generativelanguage_v1beta3.types import tuned_model as gag_tuned_model
+from google.ai.generativelanguage_v1beta3.types import model, model_service
+from google.ai.generativelanguage_v1beta3.types import tuned_model
+
+from .base import DEFAULT_CLIENT_INFO as BASE_DEFAULT_CLIENT_INFO
+from .rest_base import _BaseModelServiceRestTransport
+
+try:
+    OptionalRetry = Union[retries.Retry, gapic_v1.method._MethodDefault, None]
+except AttributeError:  # pragma: NO COVER
+    OptionalRetry = Union[retries.Retry, object, None]  # type: ignore
+
+try:
+    from google.api_core import client_logging  # type: ignore
+
+    CLIENT_LOGGING_SUPPORTED = True  # pragma: NO COVER
+except ImportError:  # pragma: NO COVER
+    CLIENT_LOGGING_SUPPORTED = False
+
+_LOGGER = logging.getLogger(__name__)
+
+DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
+    gapic_version=BASE_DEFAULT_CLIENT_INFO.gapic_version,
+    grpc_version=None,
+    rest_version=f"requests@{requests_version}",
+)
+
+
+class ModelServiceRestInterceptor:
+    """Interceptor for ModelService.
+
+    Interceptors are used to manipulate requests, request metadata, and responses
+    in arbitrary ways.
+    Example use cases include:
+    * Logging
+    * Verifying requests according to service or custom semantics
+    * Stripping extraneous information from responses
+
+    These use cases and more can be enabled by injecting an
+    instance of a custom subclass when constructing the ModelServiceRestTransport.
+
+    .. code-block:: python
+        class MyCustomModelServiceInterceptor(ModelServiceRestInterceptor):
+            def pre_create_tuned_model(self, request, metadata):
+                logging.log(f"Received request: {request}")
+                return request, metadata
+
+            def post_create_tuned_model(self, response):
+                logging.log(f"Received response: {response}")
+                return response
+
+            def pre_delete_tuned_model(self, request, metadata):
+                logging.log(f"Received request: {request}")
+                return request, metadata
+
+            def pre_get_model(self, request, metadata):
+                logging.log(f"Received request: {request}")
+                return request, metadata
+
+            def post_get_model(self, response):
+                logging.log(f"Received response: {response}")
+                return response
+
+            def pre_get_tuned_model(self, request, metadata):
+                logging.log(f"Received request: {request}")
+                return request, metadata
+
+            def post_get_tuned_model(self, response):
+                logging.log(f"Received response: {response}")
+                return response
+
+            def pre_list_models(self, request, metadata):
+                logging.log(f"Received request: {request}")
+                return request, metadata
+
+            def post_list_models(self, response):
+                logging.log(f"Received response: {response}")
+                return response
+
+            def pre_list_tuned_models(self, request, metadata):
+                logging.log(f"Received request: {request}")
+                return request, metadata
+
+            def post_list_tuned_models(self, response):
+                logging.log(f"Received response: {response}")
+                return response
+
+            def pre_update_tuned_model(self, request, metadata):
+                logging.log(f"Received request: {request}")
+                return request, metadata
+
+            def post_update_tuned_model(self, response):
+                logging.log(f"Received response: {response}")
+                return response
+
+        transport = ModelServiceRestTransport(interceptor=MyCustomModelServiceInterceptor())
+        client = ModelServiceClient(transport=transport)
+
+
+    """
+
+    def pre_create_tuned_model(
+        self,
+        request: model_service.CreateTunedModelRequest,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]],
+    ) -> Tuple[
+        model_service.CreateTunedModelRequest, Sequence[Tuple[str, Union[str, bytes]]]
+    ]:
+        """Pre-rpc interceptor for create_tuned_model
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the ModelService server.
+        """
+        return request, metadata
+
+    def post_create_tuned_model(
+        self, response: operations_pb2.Operation
+    ) -> operations_pb2.Operation:
+        """Post-rpc interceptor for create_tuned_model
+
+        Override in a subclass to manipulate the response
+        after it is returned by the ModelService server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_delete_tuned_model(
+        self,
+        request: model_service.DeleteTunedModelRequest,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]],
+    ) -> Tuple[
+        model_service.DeleteTunedModelRequest, Sequence[Tuple[str, Union[str, bytes]]]
+    ]:
+        """Pre-rpc interceptor for delete_tuned_model
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the ModelService server.
+        """
+        return request, metadata
+
+    def pre_get_model(
+        self,
+        request: model_service.GetModelRequest,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]],
+    ) -> Tuple[model_service.GetModelRequest, Sequence[Tuple[str, Union[str, bytes]]]]:
+        """Pre-rpc interceptor for get_model
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the ModelService server.
+        """
+        return request, metadata
+
+    def post_get_model(self, response: model.Model) -> model.Model:
+        """Post-rpc interceptor for get_model
+
+        Override in a subclass to manipulate the response
+        after it is returned by the ModelService server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_get_tuned_model(
+        self,
+        request: model_service.GetTunedModelRequest,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]],
+    ) -> Tuple[
+        model_service.GetTunedModelRequest, Sequence[Tuple[str, Union[str, bytes]]]
+    ]:
+        """Pre-rpc interceptor for get_tuned_model
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the ModelService server.
+        """
+        return request, metadata
+
+    def post_get_tuned_model(
+        self, response: tuned_model.TunedModel
+    ) -> tuned_model.TunedModel:
+        """Post-rpc interceptor for get_tuned_model
+
+        Override in a subclass to manipulate the response
+        after it is returned by the ModelService server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_list_models(
+        self,
+        request: model_service.ListModelsRequest,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]],
+    ) -> Tuple[
+        model_service.ListModelsRequest, Sequence[Tuple[str, Union[str, bytes]]]
+    ]:
+        """Pre-rpc interceptor for list_models
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the ModelService server.
+        """
+        return request, metadata
+
+    def post_list_models(
+        self, response: model_service.ListModelsResponse
+    ) -> model_service.ListModelsResponse:
+        """Post-rpc interceptor for list_models
+
+        Override in a subclass to manipulate the response
+        after it is returned by the ModelService server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_list_tuned_models(
+        self,
+        request: model_service.ListTunedModelsRequest,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]],
+    ) -> Tuple[
+        model_service.ListTunedModelsRequest, Sequence[Tuple[str, Union[str, bytes]]]
+    ]:
+        """Pre-rpc interceptor for list_tuned_models
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the ModelService server.
+        """
+        return request, metadata
+
+    def post_list_tuned_models(
+        self, response: model_service.ListTunedModelsResponse
+    ) -> model_service.ListTunedModelsResponse:
+        """Post-rpc interceptor for list_tuned_models
+
+        Override in a subclass to manipulate the response
+        after it is returned by the ModelService server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_update_tuned_model(
+        self,
+        request: model_service.UpdateTunedModelRequest,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]],
+    ) -> Tuple[
+        model_service.UpdateTunedModelRequest, Sequence[Tuple[str, Union[str, bytes]]]
+    ]:
+        """Pre-rpc interceptor for update_tuned_model
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the ModelService server.
+        """
+        return request, metadata
+
+    def post_update_tuned_model(
+        self, response: gag_tuned_model.TunedModel
+    ) -> gag_tuned_model.TunedModel:
+        """Post-rpc interceptor for update_tuned_model
+
+        Override in a subclass to manipulate the response
+        after it is returned by the ModelService server but before
+        it is returned to user code.
+        """
+        return response
+
+
+@dataclasses.dataclass
+class ModelServiceRestStub:
+    _session: AuthorizedSession
+    _host: str
+    _interceptor: ModelServiceRestInterceptor
+
+
+class ModelServiceRestTransport(_BaseModelServiceRestTransport):
+    """REST backend synchronous transport for ModelService.
+
+    Provides methods for getting metadata information about
+    Generative Models.
+
+    This class defines the same methods as the primary client, so the
+    primary client can load the underlying transport implementation
+    and call it.
+
+    It sends JSON representations of protocol buffers over HTTP/1.1
+    """
+
+    def __init__(
+        self,
+        *,
+        host: str = "generativelanguage.googleapis.com",
+        credentials: Optional[ga_credentials.Credentials] = None,
+        credentials_file: Optional[str] = None,
+        scopes: Optional[Sequence[str]] = None,
+        client_cert_source_for_mtls: Optional[Callable[[], Tuple[bytes, bytes]]] = None,
+        quota_project_id: Optional[str] = None,
+        client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
+        always_use_jwt_access: Optional[bool] = False,
+        url_scheme: str = "https",
+        interceptor: Optional[ModelServiceRestInterceptor] = None,
+        api_audience: Optional[str] = None,
+    ) -> None:
+        """Instantiate the transport.
+
+        Args:
+            host (Optional[str]):
+                 The hostname to connect to (default: 'generativelanguage.googleapis.com').
+            credentials (Optional[google.auth.credentials.Credentials]): The
+                authorization credentials to attach to requests. These
+                credentials identify the application to the service; if none
+                are specified, the client will attempt to ascertain the
+                credentials from the environment.
+
+            credentials_file (Optional[str]): A file with credentials that can
+                be loaded with :func:`google.auth.load_credentials_from_file`.
+                This argument is ignored if ``channel`` is provided.
+            scopes (Optional(Sequence[str])): A list of scopes. This argument is
+                ignored if ``channel`` is provided.
+            client_cert_source_for_mtls (Callable[[], Tuple[bytes, bytes]]): Client
+                certificate to configure mutual TLS HTTP channel. It is ignored
+                if ``channel`` is provided.
+            quota_project_id (Optional[str]): An optional project to use for billing
+                and quota.
+            client_info (google.api_core.gapic_v1.client_info.ClientInfo):
+                The client info used to send a user-agent string along with
+                API requests. If ``None``, then default info will be used.
+                Generally, you only need to set this if you are developing
+                your own client library.
+            always_use_jwt_access (Optional[bool]): Whether self signed JWT should
+                be used for service account credentials.
+            url_scheme: the protocol scheme for the API endpoint.  Normally
+                "https", but for testing or local servers,
+                "http" can be specified.
+        """
+        # Run the base constructor
+        # TODO(yon-mg): resolve other ctor params i.e. scopes, quota, etc.
+        # TODO: When custom host (api_endpoint) is set, `scopes` must *also* be set on the
+        # credentials object
+        super().__init__(
+            host=host,
+            credentials=credentials,
+            client_info=client_info,
+            always_use_jwt_access=always_use_jwt_access,
+            url_scheme=url_scheme,
+            api_audience=api_audience,
+        )
+        self._session = AuthorizedSession(
+            self._credentials, default_host=self.DEFAULT_HOST
+        )
+        self._operations_client: Optional[operations_v1.AbstractOperationsClient] = None
+        if client_cert_source_for_mtls:
+            self._session.configure_mtls_channel(client_cert_source_for_mtls)
+        self._interceptor = interceptor or ModelServiceRestInterceptor()
+        self._prep_wrapped_messages(client_info)
+
+    @property
+    def operations_client(self) -> operations_v1.AbstractOperationsClient:
+        """Create the client designed to process long-running operations.
+
+        This property caches on the instance; repeated calls return the same
+        client.
+        """
+        # Only create a new client if we do not already have one.
+        if self._operations_client is None:
+            http_options: Dict[str, List[Dict[str, str]]] = {}
+
+            rest_transport = operations_v1.OperationsRestTransport(
+                host=self._host,
+                # use the credentials which are saved
+                credentials=self._credentials,
+                scopes=self._scopes,
+                http_options=http_options,
+                path_prefix="v1beta3",
+            )
+
+            self._operations_client = operations_v1.AbstractOperationsClient(
+                transport=rest_transport
+            )
+
+        # Return the client from cache.
+        return self._operations_client
+
+    class _CreateTunedModel(
+        _BaseModelServiceRestTransport._BaseCreateTunedModel, ModelServiceRestStub
+    ):
+        def __hash__(self):
+            return hash("ModelServiceRestTransport.CreateTunedModel")
+
+        @staticmethod
+        def _get_response(
+            host,
+            metadata,
+            query_params,
+            session,
+            timeout,
+            transcoded_request,
+            body=None,
+        ):
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+            response = getattr(session, method)(
+                "{host}{uri}".format(host=host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params, strict=True),
+                data=body,
+            )
+            return response
+
+        def __call__(
+            self,
+            request: model_service.CreateTunedModelRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
+        ) -> operations_pb2.Operation:
+            r"""Call the create tuned model method over HTTP.
+
+            Args:
+                request (~.model_service.CreateTunedModelRequest):
+                    The request object. Request to create a TunedModel.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                    sent along with the request as metadata. Normally, each value must be of type `str`,
+                    but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                    be of type `bytes`.
+
+            Returns:
+                ~.operations_pb2.Operation:
+                    This resource represents a
+                long-running operation that is the
+                result of a network API call.
+
+            """
+
+            http_options = (
+                _BaseModelServiceRestTransport._BaseCreateTunedModel._get_http_options()
+            )
+
+            request, metadata = self._interceptor.pre_create_tuned_model(
+                request, metadata
+            )
+            transcoded_request = _BaseModelServiceRestTransport._BaseCreateTunedModel._get_transcoded_request(
+                http_options, request
+            )
+
+            body = _BaseModelServiceRestTransport._BaseCreateTunedModel._get_request_body_json(
+                transcoded_request
+            )
+
+            # Jsonify the query params
+            query_params = _BaseModelServiceRestTransport._BaseCreateTunedModel._get_query_params_json(
+                transcoded_request
+            )
+
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                logging.DEBUG
+            ):  # pragma: NO COVER
+                request_url = "{host}{uri}".format(
+                    host=self._host, uri=transcoded_request["uri"]
+                )
+                method = transcoded_request["method"]
+                try:
+                    request_payload = json_format.MessageToJson(request)
+                except:
+                    request_payload = None
+                http_request = {
+                    "payload": request_payload,
+                    "requestMethod": method,
+                    "requestUrl": request_url,
+                    "headers": dict(metadata),
+                }
+                _LOGGER.debug(
+                    f"Sending request for google.ai.generativelanguage_v1beta3.ModelServiceClient.CreateTunedModel",
+                    extra={
+                        "serviceName": "google.ai.generativelanguage.v1beta3.ModelService",
+                        "rpcName": "CreateTunedModel",
+                        "httpRequest": http_request,
+                        "metadata": http_request["headers"],
+                    },
+                )
+
+            # Send the request
+            response = ModelServiceRestTransport._CreateTunedModel._get_response(
+                self._host,
+                metadata,
+                query_params,
+                self._session,
+                timeout,
+                transcoded_request,
+                body,
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            # Return the response
+            resp = operations_pb2.Operation()
+            json_format.Parse(response.content, resp, ignore_unknown_fields=True)
+
+            resp = self._interceptor.post_create_tuned_model(resp)
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                logging.DEBUG
+            ):  # pragma: NO COVER
+                try:
+                    response_payload = json_format.MessageToJson(resp)
+                except:
+                    response_payload = None
+                http_response = {
+                    "payload": response_payload,
+                    "headers": dict(response.headers),
+                    "status": response.status_code,
+                }
+                _LOGGER.debug(
+                    "Received response for google.ai.generativelanguage_v1beta3.ModelServiceClient.create_tuned_model",
+                    extra={
+                        "serviceName": "google.ai.generativelanguage.v1beta3.ModelService",
+                        "rpcName": "CreateTunedModel",
+                        "metadata": http_response["headers"],
+                        "httpResponse": http_response,
+                    },
+                )
+            return resp
+
+    class _DeleteTunedModel(
+        _BaseModelServiceRestTransport._BaseDeleteTunedModel, ModelServiceRestStub
+    ):
+        def __hash__(self):
+            return hash("ModelServiceRestTransport.DeleteTunedModel")
+
+        @staticmethod
+        def _get_response(
+            host,
+            metadata,
+            query_params,
+            session,
+            timeout,
+            transcoded_request,
+            body=None,
+        ):
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+            response = getattr(session, method)(
+                "{host}{uri}".format(host=host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params, strict=True),
+            )
+            return response
+
+        def __call__(
+            self,
+            request: model_service.DeleteTunedModelRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
+        ):
+            r"""Call the delete tuned model method over HTTP.
+
+            Args:
+                request (~.model_service.DeleteTunedModelRequest):
+                    The request object. Request to delete a TunedModel.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                    sent along with the request as metadata. Normally, each value must be of type `str`,
+                    but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                    be of type `bytes`.
+            """
+
+            http_options = (
+                _BaseModelServiceRestTransport._BaseDeleteTunedModel._get_http_options()
+            )
+
+            request, metadata = self._interceptor.pre_delete_tuned_model(
+                request, metadata
+            )
+            transcoded_request = _BaseModelServiceRestTransport._BaseDeleteTunedModel._get_transcoded_request(
+                http_options, request
+            )
+
+            # Jsonify the query params
+            query_params = _BaseModelServiceRestTransport._BaseDeleteTunedModel._get_query_params_json(
+                transcoded_request
+            )
+
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                logging.DEBUG
+            ):  # pragma: NO COVER
+                request_url = "{host}{uri}".format(
+                    host=self._host, uri=transcoded_request["uri"]
+                )
+                method = transcoded_request["method"]
+                try:
+                    request_payload = json_format.MessageToJson(request)
+                except:
+                    request_payload = None
+                http_request = {
+                    "payload": request_payload,
+                    "requestMethod": method,
+                    "requestUrl": request_url,
+                    "headers": dict(metadata),
+                }
+                _LOGGER.debug(
+                    f"Sending request for google.ai.generativelanguage_v1beta3.ModelServiceClient.DeleteTunedModel",
+                    extra={
+                        "serviceName": "google.ai.generativelanguage.v1beta3.ModelService",
+                        "rpcName": "DeleteTunedModel",
+                        "httpRequest": http_request,
+                        "metadata": http_request["headers"],
+                    },
+                )
+
+            # Send the request
+            response = ModelServiceRestTransport._DeleteTunedModel._get_response(
+                self._host,
+                metadata,
+                query_params,
+                self._session,
+                timeout,
+                transcoded_request,
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+    class _GetModel(_BaseModelServiceRestTransport._BaseGetModel, ModelServiceRestStub):
+        def __hash__(self):
+            return hash("ModelServiceRestTransport.GetModel")
+
+        @staticmethod
+        def _get_response(
+            host,
+            metadata,
+            query_params,
+            session,
+            timeout,
+            transcoded_request,
+            body=None,
+        ):
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+            response = getattr(session, method)(
+                "{host}{uri}".format(host=host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params, strict=True),
+            )
+            return response
+
+        def __call__(
+            self,
+            request: model_service.GetModelRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
+        ) -> model.Model:
+            r"""Call the get model method over HTTP.
+
+            Args:
+                request (~.model_service.GetModelRequest):
+                    The request object. Request for getting information about
+                a specific Model.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                    sent along with the request as metadata. Normally, each value must be of type `str`,
+                    but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                    be of type `bytes`.
+
+            Returns:
+                ~.model.Model:
+                    Information about a Generative
+                Language Model.
+
+            """
+
+            http_options = (
+                _BaseModelServiceRestTransport._BaseGetModel._get_http_options()
+            )
+
+            request, metadata = self._interceptor.pre_get_model(request, metadata)
+            transcoded_request = (
+                _BaseModelServiceRestTransport._BaseGetModel._get_transcoded_request(
+                    http_options, request
+                )
+            )
+
+            # Jsonify the query params
+            query_params = (
+                _BaseModelServiceRestTransport._BaseGetModel._get_query_params_json(
+                    transcoded_request
+                )
+            )
+
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                logging.DEBUG
+            ):  # pragma: NO COVER
+                request_url = "{host}{uri}".format(
+                    host=self._host, uri=transcoded_request["uri"]
+                )
+                method = transcoded_request["method"]
+                try:
+                    request_payload = type(request).to_json(request)
+                except:
+                    request_payload = None
+                http_request = {
+                    "payload": request_payload,
+                    "requestMethod": method,
+                    "requestUrl": request_url,
+                    "headers": dict(metadata),
+                }
+                _LOGGER.debug(
+                    f"Sending request for google.ai.generativelanguage_v1beta3.ModelServiceClient.GetModel",
+                    extra={
+                        "serviceName": "google.ai.generativelanguage.v1beta3.ModelService",
+                        "rpcName": "GetModel",
+                        "httpRequest": http_request,
+                        "metadata": http_request["headers"],
+                    },
+                )
+
+            # Send the request
+            response = ModelServiceRestTransport._GetModel._get_response(
+                self._host,
+                metadata,
+                query_params,
+                self._session,
+                timeout,
+                transcoded_request,
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            # Return the response
+            resp = model.Model()
+            pb_resp = model.Model.pb(resp)
+
+            json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
+
+            resp = self._interceptor.post_get_model(resp)
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                logging.DEBUG
+            ):  # pragma: NO COVER
+                try:
+                    response_payload = model.Model.to_json(response)
+                except:
+                    response_payload = None
+                http_response = {
+                    "payload": response_payload,
+                    "headers": dict(response.headers),
+                    "status": response.status_code,
+                }
+                _LOGGER.debug(
+                    "Received response for google.ai.generativelanguage_v1beta3.ModelServiceClient.get_model",
+                    extra={
+                        "serviceName": "google.ai.generativelanguage.v1beta3.ModelService",
+                        "rpcName": "GetModel",
+                        "metadata": http_response["headers"],
+                        "httpResponse": http_response,
+                    },
+                )
+            return resp
+
+    class _GetTunedModel(
+        _BaseModelServiceRestTransport._BaseGetTunedModel, ModelServiceRestStub
+    ):
+        def __hash__(self):
+            return hash("ModelServiceRestTransport.GetTunedModel")
+
+        @staticmethod
+        def _get_response(
+            host,
+            metadata,
+            query_params,
+            session,
+            timeout,
+            transcoded_request,
+            body=None,
+        ):
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+            response = getattr(session, method)(
+                "{host}{uri}".format(host=host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params, strict=True),
+            )
+            return response
+
+        def __call__(
+            self,
+            request: model_service.GetTunedModelRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
+        ) -> tuned_model.TunedModel:
+            r"""Call the get tuned model method over HTTP.
+
+            Args:
+                request (~.model_service.GetTunedModelRequest):
+                    The request object. Request for getting information about
+                a specific Model.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                    sent along with the request as metadata. Normally, each value must be of type `str`,
+                    but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                    be of type `bytes`.
+
+            Returns:
+                ~.tuned_model.TunedModel:
+                    A fine-tuned model created using
+                ModelService.CreateTunedModel.
+
+            """
+
+            http_options = (
+                _BaseModelServiceRestTransport._BaseGetTunedModel._get_http_options()
+            )
+
+            request, metadata = self._interceptor.pre_get_tuned_model(request, metadata)
+            transcoded_request = _BaseModelServiceRestTransport._BaseGetTunedModel._get_transcoded_request(
+                http_options, request
+            )
+
+            # Jsonify the query params
+            query_params = _BaseModelServiceRestTransport._BaseGetTunedModel._get_query_params_json(
+                transcoded_request
+            )
+
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                logging.DEBUG
+            ):  # pragma: NO COVER
+                request_url = "{host}{uri}".format(
+                    host=self._host, uri=transcoded_request["uri"]
+                )
+                method = transcoded_request["method"]
+                try:
+                    request_payload = type(request).to_json(request)
+                except:
+                    request_payload = None
+                http_request = {
+                    "payload": request_payload,
+                    "requestMethod": method,
+                    "requestUrl": request_url,
+                    "headers": dict(metadata),
+                }
+                _LOGGER.debug(
+                    f"Sending request for google.ai.generativelanguage_v1beta3.ModelServiceClient.GetTunedModel",
+                    extra={
+                        "serviceName": "google.ai.generativelanguage.v1beta3.ModelService",
+                        "rpcName": "GetTunedModel",
+                        "httpRequest": http_request,
+                        "metadata": http_request["headers"],
+                    },
+                )
+
+            # Send the request
+            response = ModelServiceRestTransport._GetTunedModel._get_response(
+                self._host,
+                metadata,
+                query_params,
+                self._session,
+                timeout,
+                transcoded_request,
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            # Return the response
+            resp = tuned_model.TunedModel()
+            pb_resp = tuned_model.TunedModel.pb(resp)
+
+            json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
+
+            resp = self._interceptor.post_get_tuned_model(resp)
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                logging.DEBUG
+            ):  # pragma: NO COVER
+                try:
+                    response_payload = tuned_model.TunedModel.to_json(response)
+                except:
+                    response_payload = None
+                http_response = {
+                    "payload": response_payload,
+                    "headers": dict(response.headers),
+                    "status": response.status_code,
+                }
+                _LOGGER.debug(
+                    "Received response for google.ai.generativelanguage_v1beta3.ModelServiceClient.get_tuned_model",
+                    extra={
+                        "serviceName": "google.ai.generativelanguage.v1beta3.ModelService",
+                        "rpcName": "GetTunedModel",
+                        "metadata": http_response["headers"],
+                        "httpResponse": http_response,
+                    },
+                )
+            return resp
+
+    class _ListModels(
+        _BaseModelServiceRestTransport._BaseListModels, ModelServiceRestStub
+    ):
+        def __hash__(self):
+            return hash("ModelServiceRestTransport.ListModels")
+
+        @staticmethod
+        def _get_response(
+            host,
+            metadata,
+            query_params,
+            session,
+            timeout,
+            transcoded_request,
+            body=None,
+        ):
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+            response = getattr(session, method)(
+                "{host}{uri}".format(host=host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params, strict=True),
+            )
+            return response
+
+        def __call__(
+            self,
+            request: model_service.ListModelsRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
+        ) -> model_service.ListModelsResponse:
+            r"""Call the list models method over HTTP.
+
+            Args:
+                request (~.model_service.ListModelsRequest):
+                    The request object. Request for listing all Models.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                    sent along with the request as metadata. Normally, each value must be of type `str`,
+                    but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                    be of type `bytes`.
+
+            Returns:
+                ~.model_service.ListModelsResponse:
+                    Response from ``ListModel`` containing a paginated list
+                of Models.
+
+            """
+
+            http_options = (
+                _BaseModelServiceRestTransport._BaseListModels._get_http_options()
+            )
+
+            request, metadata = self._interceptor.pre_list_models(request, metadata)
+            transcoded_request = (
+                _BaseModelServiceRestTransport._BaseListModels._get_transcoded_request(
+                    http_options, request
+                )
+            )
+
+            # Jsonify the query params
+            query_params = (
+                _BaseModelServiceRestTransport._BaseListModels._get_query_params_json(
+                    transcoded_request
+                )
+            )
+
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                logging.DEBUG
+            ):  # pragma: NO COVER
+                request_url = "{host}{uri}".format(
+                    host=self._host, uri=transcoded_request["uri"]
+                )
+                method = transcoded_request["method"]
+                try:
+                    request_payload = type(request).to_json(request)
+                except:
+                    request_payload = None
+                http_request = {
+                    "payload": request_payload,
+                    "requestMethod": method,
+                    "requestUrl": request_url,
+                    "headers": dict(metadata),
+                }
+                _LOGGER.debug(
+                    f"Sending request for google.ai.generativelanguage_v1beta3.ModelServiceClient.ListModels",
+                    extra={
+                        "serviceName": "google.ai.generativelanguage.v1beta3.ModelService",
+                        "rpcName": "ListModels",
+                        "httpRequest": http_request,
+                        "metadata": http_request["headers"],
+                    },
+                )
+
+            # Send the request
+            response = ModelServiceRestTransport._ListModels._get_response(
+                self._host,
+                metadata,
+                query_params,
+                self._session,
+                timeout,
+                transcoded_request,
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            # Return the response
+            resp = model_service.ListModelsResponse()
+            pb_resp = model_service.ListModelsResponse.pb(resp)
+
+            json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
+
+            resp = self._interceptor.post_list_models(resp)
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                logging.DEBUG
+            ):  # pragma: NO COVER
+                try:
+                    response_payload = model_service.ListModelsResponse.to_json(
+                        response
+                    )
+                except:
+                    response_payload = None
+                http_response = {
+                    "payload": response_payload,
+                    "headers": dict(response.headers),
+                    "status": response.status_code,
+                }
+                _LOGGER.debug(
+                    "Received response for google.ai.generativelanguage_v1beta3.ModelServiceClient.list_models",
+                    extra={
+                        "serviceName": "google.ai.generativelanguage.v1beta3.ModelService",
+                        "rpcName": "ListModels",
+                        "metadata": http_response["headers"],
+                        "httpResponse": http_response,
+                    },
+                )
+            return resp
+
+    class _ListTunedModels(
+        _BaseModelServiceRestTransport._BaseListTunedModels, ModelServiceRestStub
+    ):
+        def __hash__(self):
+            return hash("ModelServiceRestTransport.ListTunedModels")
+
+        @staticmethod
+        def _get_response(
+            host,
+            metadata,
+            query_params,
+            session,
+            timeout,
+            transcoded_request,
+            body=None,
+        ):
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+            response = getattr(session, method)(
+                "{host}{uri}".format(host=host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params, strict=True),
+            )
+            return response
+
+        def __call__(
+            self,
+            request: model_service.ListTunedModelsRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
+        ) -> model_service.ListTunedModelsResponse:
+            r"""Call the list tuned models method over HTTP.
+
+            Args:
+                request (~.model_service.ListTunedModelsRequest):
+                    The request object. Request for listing TunedModels.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                    sent along with the request as metadata. Normally, each value must be of type `str`,
+                    but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                    be of type `bytes`.
+
+            Returns:
+                ~.model_service.ListTunedModelsResponse:
+                    Response from ``ListTunedModels`` containing a paginated
+                list of Models.
+
+            """
+
+            http_options = (
+                _BaseModelServiceRestTransport._BaseListTunedModels._get_http_options()
+            )
+
+            request, metadata = self._interceptor.pre_list_tuned_models(
+                request, metadata
+            )
+            transcoded_request = _BaseModelServiceRestTransport._BaseListTunedModels._get_transcoded_request(
+                http_options, request
+            )
+
+            # Jsonify the query params
+            query_params = _BaseModelServiceRestTransport._BaseListTunedModels._get_query_params_json(
+                transcoded_request
+            )
+
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                logging.DEBUG
+            ):  # pragma: NO COVER
+                request_url = "{host}{uri}".format(
+                    host=self._host, uri=transcoded_request["uri"]
+                )
+                method = transcoded_request["method"]
+                try:
+                    request_payload = type(request).to_json(request)
+                except:
+                    request_payload = None
+                http_request = {
+                    "payload": request_payload,
+                    "requestMethod": method,
+                    "requestUrl": request_url,
+                    "headers": dict(metadata),
+                }
+                _LOGGER.debug(
+                    f"Sending request for google.ai.generativelanguage_v1beta3.ModelServiceClient.ListTunedModels",
+                    extra={
+                        "serviceName": "google.ai.generativelanguage.v1beta3.ModelService",
+                        "rpcName": "ListTunedModels",
+                        "httpRequest": http_request,
+                        "metadata": http_request["headers"],
+                    },
+                )
+
+            # Send the request
+            response = ModelServiceRestTransport._ListTunedModels._get_response(
+                self._host,
+                metadata,
+                query_params,
+                self._session,
+                timeout,
+                transcoded_request,
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            # Return the response
+            resp = model_service.ListTunedModelsResponse()
+            pb_resp = model_service.ListTunedModelsResponse.pb(resp)
+
+            json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
+
+            resp = self._interceptor.post_list_tuned_models(resp)
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                logging.DEBUG
+            ):  # pragma: NO COVER
+                try:
+                    response_payload = model_service.ListTunedModelsResponse.to_json(
+                        response
+                    )
+                except:
+                    response_payload = None
+                http_response = {
+                    "payload": response_payload,
+                    "headers": dict(response.headers),
+                    "status": response.status_code,
+                }
+                _LOGGER.debug(
+                    "Received response for google.ai.generativelanguage_v1beta3.ModelServiceClient.list_tuned_models",
+                    extra={
+                        "serviceName": "google.ai.generativelanguage.v1beta3.ModelService",
+                        "rpcName": "ListTunedModels",
+                        "metadata": http_response["headers"],
+                        "httpResponse": http_response,
+                    },
+                )
+            return resp
+
+    class _UpdateTunedModel(
+        _BaseModelServiceRestTransport._BaseUpdateTunedModel, ModelServiceRestStub
+    ):
+        def __hash__(self):
+            return hash("ModelServiceRestTransport.UpdateTunedModel")
+
+        @staticmethod
+        def _get_response(
+            host,
+            metadata,
+            query_params,
+            session,
+            timeout,
+            transcoded_request,
+            body=None,
+        ):
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+            response = getattr(session, method)(
+                "{host}{uri}".format(host=host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params, strict=True),
+                data=body,
+            )
+            return response
+
+        def __call__(
+            self,
+            request: model_service.UpdateTunedModelRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
+        ) -> gag_tuned_model.TunedModel:
+            r"""Call the update tuned model method over HTTP.
+
+            Args:
+                request (~.model_service.UpdateTunedModelRequest):
+                    The request object. Request to update a TunedModel.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                    sent along with the request as metadata. Normally, each value must be of type `str`,
+                    but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                    be of type `bytes`.
+
+            Returns:
+                ~.gag_tuned_model.TunedModel:
+                    A fine-tuned model created using
+                ModelService.CreateTunedModel.
+
+            """
+
+            http_options = (
+                _BaseModelServiceRestTransport._BaseUpdateTunedModel._get_http_options()
+            )
+
+            request, metadata = self._interceptor.pre_update_tuned_model(
+                request, metadata
+            )
+            transcoded_request = _BaseModelServiceRestTransport._BaseUpdateTunedModel._get_transcoded_request(
+                http_options, request
+            )
+
+            body = _BaseModelServiceRestTransport._BaseUpdateTunedModel._get_request_body_json(
+                transcoded_request
+            )
+
+            # Jsonify the query params
+            query_params = _BaseModelServiceRestTransport._BaseUpdateTunedModel._get_query_params_json(
+                transcoded_request
+            )
+
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                logging.DEBUG
+            ):  # pragma: NO COVER
+                request_url = "{host}{uri}".format(
+                    host=self._host, uri=transcoded_request["uri"]
+                )
+                method = transcoded_request["method"]
+                try:
+                    request_payload = type(request).to_json(request)
+                except:
+                    request_payload = None
+                http_request = {
+                    "payload": request_payload,
+                    "requestMethod": method,
+                    "requestUrl": request_url,
+                    "headers": dict(metadata),
+                }
+                _LOGGER.debug(
+                    f"Sending request for google.ai.generativelanguage_v1beta3.ModelServiceClient.UpdateTunedModel",
+                    extra={
+                        "serviceName": "google.ai.generativelanguage.v1beta3.ModelService",
+                        "rpcName": "UpdateTunedModel",
+                        "httpRequest": http_request,
+                        "metadata": http_request["headers"],
+                    },
+                )
+
+            # Send the request
+            response = ModelServiceRestTransport._UpdateTunedModel._get_response(
+                self._host,
+                metadata,
+                query_params,
+                self._session,
+                timeout,
+                transcoded_request,
+                body,
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            # Return the response
+            resp = gag_tuned_model.TunedModel()
+            pb_resp = gag_tuned_model.TunedModel.pb(resp)
+
+            json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
+
+            resp = self._interceptor.post_update_tuned_model(resp)
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                logging.DEBUG
+            ):  # pragma: NO COVER
+                try:
+                    response_payload = gag_tuned_model.TunedModel.to_json(response)
+                except:
+                    response_payload = None
+                http_response = {
+                    "payload": response_payload,
+                    "headers": dict(response.headers),
+                    "status": response.status_code,
+                }
+                _LOGGER.debug(
+                    "Received response for google.ai.generativelanguage_v1beta3.ModelServiceClient.update_tuned_model",
+                    extra={
+                        "serviceName": "google.ai.generativelanguage.v1beta3.ModelService",
+                        "rpcName": "UpdateTunedModel",
+                        "metadata": http_response["headers"],
+                        "httpResponse": http_response,
+                    },
+                )
+            return resp
+
+    @property
+    def create_tuned_model(
+        self,
+    ) -> Callable[[model_service.CreateTunedModelRequest], operations_pb2.Operation]:
+        # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
+        # In C++ this would require a dynamic_cast
+        return self._CreateTunedModel(self._session, self._host, self._interceptor)  # type: ignore
+
+    @property
+    def delete_tuned_model(
+        self,
+    ) -> Callable[[model_service.DeleteTunedModelRequest], empty_pb2.Empty]:
+        # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
+        # In C++ this would require a dynamic_cast
+        return self._DeleteTunedModel(self._session, self._host, self._interceptor)  # type: ignore
+
+    @property
+    def get_model(self) -> Callable[[model_service.GetModelRequest], model.Model]:
+        # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
+        # In C++ this would require a dynamic_cast
+        return self._GetModel(self._session, self._host, self._interceptor)  # type: ignore
+
+    @property
+    def get_tuned_model(
+        self,
+    ) -> Callable[[model_service.GetTunedModelRequest], tuned_model.TunedModel]:
+        # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
+        # In C++ this would require a dynamic_cast
+        return self._GetTunedModel(self._session, self._host, self._interceptor)  # type: ignore
+
+    @property
+    def list_models(
+        self,
+    ) -> Callable[[model_service.ListModelsRequest], model_service.ListModelsResponse]:
+        # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
+        # In C++ this would require a dynamic_cast
+        return self._ListModels(self._session, self._host, self._interceptor)  # type: ignore
+
+    @property
+    def list_tuned_models(
+        self,
+    ) -> Callable[
+        [model_service.ListTunedModelsRequest], model_service.ListTunedModelsResponse
+    ]:
+        # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
+        # In C++ this would require a dynamic_cast
+        return self._ListTunedModels(self._session, self._host, self._interceptor)  # type: ignore
+
+    @property
+    def update_tuned_model(
+        self,
+    ) -> Callable[[model_service.UpdateTunedModelRequest], gag_tuned_model.TunedModel]:
+        # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
+        # In C++ this would require a dynamic_cast
+        return self._UpdateTunedModel(self._session, self._host, self._interceptor)  # type: ignore
+
+    @property
+    def kind(self) -> str:
+        return "rest"
+
+    def close(self):
+        self._session.close()
+
+
+__all__ = ("ModelServiceRestTransport",)

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/services/model_service/transports/rest_base.py

@@ -0,0 +1,416 @@
+# -*- coding: utf-8 -*-
+# 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 json  # type: ignore
+import re
+from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union
+
+from google.api_core import gapic_v1, path_template
+from google.longrunning import operations_pb2  # type: ignore
+from google.protobuf import empty_pb2  # type: ignore
+from google.protobuf import json_format
+
+from google.ai.generativelanguage_v1beta3.types import tuned_model as gag_tuned_model
+from google.ai.generativelanguage_v1beta3.types import model, model_service
+from google.ai.generativelanguage_v1beta3.types import tuned_model
+
+from .base import DEFAULT_CLIENT_INFO, ModelServiceTransport
+
+
+class _BaseModelServiceRestTransport(ModelServiceTransport):
+    """Base REST backend transport for ModelService.
+
+    Note: This class is not meant to be used directly. Use its sync and
+    async sub-classes instead.
+
+    This class defines the same methods as the primary client, so the
+    primary client can load the underlying transport implementation
+    and call it.
+
+    It sends JSON representations of protocol buffers over HTTP/1.1
+    """
+
+    def __init__(
+        self,
+        *,
+        host: str = "generativelanguage.googleapis.com",
+        credentials: Optional[Any] = None,
+        client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
+        always_use_jwt_access: Optional[bool] = False,
+        url_scheme: str = "https",
+        api_audience: Optional[str] = None,
+    ) -> None:
+        """Instantiate the transport.
+        Args:
+            host (Optional[str]):
+                 The hostname to connect to (default: 'generativelanguage.googleapis.com').
+            credentials (Optional[Any]): The
+                authorization credentials to attach to requests. These
+                credentials identify the application to the service; if none
+                are specified, the client will attempt to ascertain the
+                credentials from the environment.
+            client_info (google.api_core.gapic_v1.client_info.ClientInfo):
+                The client info used to send a user-agent string along with
+                API requests. If ``None``, then default info will be used.
+                Generally, you only need to set this if you are developing
+                your own client library.
+            always_use_jwt_access (Optional[bool]): Whether self signed JWT should
+                be used for service account credentials.
+            url_scheme: the protocol scheme for the API endpoint.  Normally
+                "https", but for testing or local servers,
+                "http" can be specified.
+        """
+        # Run the base constructor
+        maybe_url_match = re.match("^(?P<scheme>http(?:s)?://)?(?P<host>.*)$", host)
+        if maybe_url_match is None:
+            raise ValueError(
+                f"Unexpected hostname structure: {host}"
+            )  # pragma: NO COVER
+
+        url_match_items = maybe_url_match.groupdict()
+
+        host = f"{url_scheme}://{host}" if not url_match_items["scheme"] else host
+
+        super().__init__(
+            host=host,
+            credentials=credentials,
+            client_info=client_info,
+            always_use_jwt_access=always_use_jwt_access,
+            api_audience=api_audience,
+        )
+
+    class _BaseCreateTunedModel:
+        def __hash__(self):  # pragma: NO COVER
+            return NotImplementedError("__hash__ must be implemented.")
+
+        __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+        @classmethod
+        def _get_unset_required_fields(cls, message_dict):
+            return {
+                k: v
+                for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+                if k not in message_dict
+            }
+
+        @staticmethod
+        def _get_http_options():
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1beta3/tunedModels",
+                    "body": "tuned_model",
+                },
+            ]
+            return http_options
+
+        @staticmethod
+        def _get_transcoded_request(http_options, request):
+            pb_request = model_service.CreateTunedModelRequest.pb(request)
+            transcoded_request = path_template.transcode(http_options, pb_request)
+            return transcoded_request
+
+        @staticmethod
+        def _get_request_body_json(transcoded_request):
+            # Jsonify the request body
+
+            body = json_format.MessageToJson(
+                transcoded_request["body"], use_integers_for_enums=True
+            )
+            return body
+
+        @staticmethod
+        def _get_query_params_json(transcoded_request):
+            query_params = json.loads(
+                json_format.MessageToJson(
+                    transcoded_request["query_params"],
+                    use_integers_for_enums=True,
+                )
+            )
+            query_params.update(
+                _BaseModelServiceRestTransport._BaseCreateTunedModel._get_unset_required_fields(
+                    query_params
+                )
+            )
+
+            query_params["$alt"] = "json;enum-encoding=int"
+            return query_params
+
+    class _BaseDeleteTunedModel:
+        def __hash__(self):  # pragma: NO COVER
+            return NotImplementedError("__hash__ must be implemented.")
+
+        __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+        @classmethod
+        def _get_unset_required_fields(cls, message_dict):
+            return {
+                k: v
+                for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+                if k not in message_dict
+            }
+
+        @staticmethod
+        def _get_http_options():
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "delete",
+                    "uri": "/v1beta3/{name=tunedModels/*}",
+                },
+            ]
+            return http_options
+
+        @staticmethod
+        def _get_transcoded_request(http_options, request):
+            pb_request = model_service.DeleteTunedModelRequest.pb(request)
+            transcoded_request = path_template.transcode(http_options, pb_request)
+            return transcoded_request
+
+        @staticmethod
+        def _get_query_params_json(transcoded_request):
+            query_params = json.loads(
+                json_format.MessageToJson(
+                    transcoded_request["query_params"],
+                    use_integers_for_enums=True,
+                )
+            )
+            query_params.update(
+                _BaseModelServiceRestTransport._BaseDeleteTunedModel._get_unset_required_fields(
+                    query_params
+                )
+            )
+
+            query_params["$alt"] = "json;enum-encoding=int"
+            return query_params
+
+    class _BaseGetModel:
+        def __hash__(self):  # pragma: NO COVER
+            return NotImplementedError("__hash__ must be implemented.")
+
+        __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+        @classmethod
+        def _get_unset_required_fields(cls, message_dict):
+            return {
+                k: v
+                for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+                if k not in message_dict
+            }
+
+        @staticmethod
+        def _get_http_options():
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "get",
+                    "uri": "/v1beta3/{name=models/*}",
+                },
+            ]
+            return http_options
+
+        @staticmethod
+        def _get_transcoded_request(http_options, request):
+            pb_request = model_service.GetModelRequest.pb(request)
+            transcoded_request = path_template.transcode(http_options, pb_request)
+            return transcoded_request
+
+        @staticmethod
+        def _get_query_params_json(transcoded_request):
+            query_params = json.loads(
+                json_format.MessageToJson(
+                    transcoded_request["query_params"],
+                    use_integers_for_enums=True,
+                )
+            )
+            query_params.update(
+                _BaseModelServiceRestTransport._BaseGetModel._get_unset_required_fields(
+                    query_params
+                )
+            )
+
+            query_params["$alt"] = "json;enum-encoding=int"
+            return query_params
+
+    class _BaseGetTunedModel:
+        def __hash__(self):  # pragma: NO COVER
+            return NotImplementedError("__hash__ must be implemented.")
+
+        __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+        @classmethod
+        def _get_unset_required_fields(cls, message_dict):
+            return {
+                k: v
+                for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+                if k not in message_dict
+            }
+
+        @staticmethod
+        def _get_http_options():
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "get",
+                    "uri": "/v1beta3/{name=tunedModels/*}",
+                },
+            ]
+            return http_options
+
+        @staticmethod
+        def _get_transcoded_request(http_options, request):
+            pb_request = model_service.GetTunedModelRequest.pb(request)
+            transcoded_request = path_template.transcode(http_options, pb_request)
+            return transcoded_request
+
+        @staticmethod
+        def _get_query_params_json(transcoded_request):
+            query_params = json.loads(
+                json_format.MessageToJson(
+                    transcoded_request["query_params"],
+                    use_integers_for_enums=True,
+                )
+            )
+            query_params.update(
+                _BaseModelServiceRestTransport._BaseGetTunedModel._get_unset_required_fields(
+                    query_params
+                )
+            )
+
+            query_params["$alt"] = "json;enum-encoding=int"
+            return query_params
+
+    class _BaseListModels:
+        def __hash__(self):  # pragma: NO COVER
+            return NotImplementedError("__hash__ must be implemented.")
+
+        @staticmethod
+        def _get_http_options():
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "get",
+                    "uri": "/v1beta3/models",
+                },
+            ]
+            return http_options
+
+        @staticmethod
+        def _get_transcoded_request(http_options, request):
+            pb_request = model_service.ListModelsRequest.pb(request)
+            transcoded_request = path_template.transcode(http_options, pb_request)
+            return transcoded_request
+
+        @staticmethod
+        def _get_query_params_json(transcoded_request):
+            query_params = json.loads(
+                json_format.MessageToJson(
+                    transcoded_request["query_params"],
+                    use_integers_for_enums=True,
+                )
+            )
+
+            query_params["$alt"] = "json;enum-encoding=int"
+            return query_params
+
+    class _BaseListTunedModels:
+        def __hash__(self):  # pragma: NO COVER
+            return NotImplementedError("__hash__ must be implemented.")
+
+        @staticmethod
+        def _get_http_options():
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "get",
+                    "uri": "/v1beta3/tunedModels",
+                },
+            ]
+            return http_options
+
+        @staticmethod
+        def _get_transcoded_request(http_options, request):
+            pb_request = model_service.ListTunedModelsRequest.pb(request)
+            transcoded_request = path_template.transcode(http_options, pb_request)
+            return transcoded_request
+
+        @staticmethod
+        def _get_query_params_json(transcoded_request):
+            query_params = json.loads(
+                json_format.MessageToJson(
+                    transcoded_request["query_params"],
+                    use_integers_for_enums=True,
+                )
+            )
+
+            query_params["$alt"] = "json;enum-encoding=int"
+            return query_params
+
+    class _BaseUpdateTunedModel:
+        def __hash__(self):  # pragma: NO COVER
+            return NotImplementedError("__hash__ must be implemented.")
+
+        __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {
+            "updateMask": {},
+        }
+
+        @classmethod
+        def _get_unset_required_fields(cls, message_dict):
+            return {
+                k: v
+                for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+                if k not in message_dict
+            }
+
+        @staticmethod
+        def _get_http_options():
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "patch",
+                    "uri": "/v1beta3/{tuned_model.name=tunedModels/*}",
+                    "body": "tuned_model",
+                },
+            ]
+            return http_options
+
+        @staticmethod
+        def _get_transcoded_request(http_options, request):
+            pb_request = model_service.UpdateTunedModelRequest.pb(request)
+            transcoded_request = path_template.transcode(http_options, pb_request)
+            return transcoded_request
+
+        @staticmethod
+        def _get_request_body_json(transcoded_request):
+            # Jsonify the request body
+
+            body = json_format.MessageToJson(
+                transcoded_request["body"], use_integers_for_enums=True
+            )
+            return body
+
+        @staticmethod
+        def _get_query_params_json(transcoded_request):
+            query_params = json.loads(
+                json_format.MessageToJson(
+                    transcoded_request["query_params"],
+                    use_integers_for_enums=True,
+                )
+            )
+            query_params.update(
+                _BaseModelServiceRestTransport._BaseUpdateTunedModel._get_unset_required_fields(
+                    query_params
+                )
+            )
+
+            query_params["$alt"] = "json;enum-encoding=int"
+            return query_params
+
+
+__all__ = ("_BaseModelServiceRestTransport",)

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/services/permission_service/__init__.py

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+# 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 .async_client import PermissionServiceAsyncClient
+from .client import PermissionServiceClient
+
+__all__ = (
+    "PermissionServiceClient",
+    "PermissionServiceAsyncClient",
+)

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/services/permission_service/async_client.py

@@ -0,0 +1,1040 @@
+# -*- coding: utf-8 -*-
+# 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 collections import OrderedDict
+import logging as std_logging
+import re
+from typing import (
+    Callable,
+    Dict,
+    Mapping,
+    MutableMapping,
+    MutableSequence,
+    Optional,
+    Sequence,
+    Tuple,
+    Type,
+    Union,
+)
+
+from google.api_core import exceptions as core_exceptions
+from google.api_core import gapic_v1
+from google.api_core import retry_async as retries
+from google.api_core.client_options import ClientOptions
+from google.auth import credentials as ga_credentials  # type: ignore
+from google.oauth2 import service_account  # type: ignore
+
+from google.ai.generativelanguage_v1beta3 import gapic_version as package_version
+
+try:
+    OptionalRetry = Union[retries.AsyncRetry, gapic_v1.method._MethodDefault, None]
+except AttributeError:  # pragma: NO COVER
+    OptionalRetry = Union[retries.AsyncRetry, object, None]  # type: ignore
+
+from google.longrunning import operations_pb2  # type: ignore
+from google.protobuf import field_mask_pb2  # type: ignore
+
+from google.ai.generativelanguage_v1beta3.services.permission_service import pagers
+from google.ai.generativelanguage_v1beta3.types import permission as gag_permission
+from google.ai.generativelanguage_v1beta3.types import permission
+from google.ai.generativelanguage_v1beta3.types import permission_service
+
+from .client import PermissionServiceClient
+from .transports.base import DEFAULT_CLIENT_INFO, PermissionServiceTransport
+from .transports.grpc_asyncio import PermissionServiceGrpcAsyncIOTransport
+
+try:
+    from google.api_core import client_logging  # type: ignore
+
+    CLIENT_LOGGING_SUPPORTED = True  # pragma: NO COVER
+except ImportError:  # pragma: NO COVER
+    CLIENT_LOGGING_SUPPORTED = False
+
+_LOGGER = std_logging.getLogger(__name__)
+
+
+class PermissionServiceAsyncClient:
+    """Provides methods for managing permissions to PaLM API
+    resources.
+    """
+
+    _client: PermissionServiceClient
+
+    # Copy defaults from the synchronous client for use here.
+    # Note: DEFAULT_ENDPOINT is deprecated. Use _DEFAULT_ENDPOINT_TEMPLATE instead.
+    DEFAULT_ENDPOINT = PermissionServiceClient.DEFAULT_ENDPOINT
+    DEFAULT_MTLS_ENDPOINT = PermissionServiceClient.DEFAULT_MTLS_ENDPOINT
+    _DEFAULT_ENDPOINT_TEMPLATE = PermissionServiceClient._DEFAULT_ENDPOINT_TEMPLATE
+    _DEFAULT_UNIVERSE = PermissionServiceClient._DEFAULT_UNIVERSE
+
+    permission_path = staticmethod(PermissionServiceClient.permission_path)
+    parse_permission_path = staticmethod(PermissionServiceClient.parse_permission_path)
+    tuned_model_path = staticmethod(PermissionServiceClient.tuned_model_path)
+    parse_tuned_model_path = staticmethod(
+        PermissionServiceClient.parse_tuned_model_path
+    )
+    common_billing_account_path = staticmethod(
+        PermissionServiceClient.common_billing_account_path
+    )
+    parse_common_billing_account_path = staticmethod(
+        PermissionServiceClient.parse_common_billing_account_path
+    )
+    common_folder_path = staticmethod(PermissionServiceClient.common_folder_path)
+    parse_common_folder_path = staticmethod(
+        PermissionServiceClient.parse_common_folder_path
+    )
+    common_organization_path = staticmethod(
+        PermissionServiceClient.common_organization_path
+    )
+    parse_common_organization_path = staticmethod(
+        PermissionServiceClient.parse_common_organization_path
+    )
+    common_project_path = staticmethod(PermissionServiceClient.common_project_path)
+    parse_common_project_path = staticmethod(
+        PermissionServiceClient.parse_common_project_path
+    )
+    common_location_path = staticmethod(PermissionServiceClient.common_location_path)
+    parse_common_location_path = staticmethod(
+        PermissionServiceClient.parse_common_location_path
+    )
+
+    @classmethod
+    def from_service_account_info(cls, info: dict, *args, **kwargs):
+        """Creates an instance of this client using the provided credentials
+            info.
+
+        Args:
+            info (dict): The service account private key info.
+            args: Additional arguments to pass to the constructor.
+            kwargs: Additional arguments to pass to the constructor.
+
+        Returns:
+            PermissionServiceAsyncClient: The constructed client.
+        """
+        return PermissionServiceClient.from_service_account_info.__func__(PermissionServiceAsyncClient, info, *args, **kwargs)  # type: ignore
+
+    @classmethod
+    def from_service_account_file(cls, filename: str, *args, **kwargs):
+        """Creates an instance of this client using the provided credentials
+            file.
+
+        Args:
+            filename (str): The path to the service account private key json
+                file.
+            args: Additional arguments to pass to the constructor.
+            kwargs: Additional arguments to pass to the constructor.
+
+        Returns:
+            PermissionServiceAsyncClient: The constructed client.
+        """
+        return PermissionServiceClient.from_service_account_file.__func__(PermissionServiceAsyncClient, filename, *args, **kwargs)  # type: ignore
+
+    from_service_account_json = from_service_account_file
+
+    @classmethod
+    def get_mtls_endpoint_and_cert_source(
+        cls, client_options: Optional[ClientOptions] = None
+    ):
+        """Return the API endpoint and client cert source for mutual TLS.
+
+        The client cert source is determined in the following order:
+        (1) if `GOOGLE_API_USE_CLIENT_CERTIFICATE` environment variable is not "true", the
+        client cert source is None.
+        (2) if `client_options.client_cert_source` is provided, use the provided one; if the
+        default client cert source exists, use the default one; otherwise the client cert
+        source is None.
+
+        The API endpoint is determined in the following order:
+        (1) if `client_options.api_endpoint` if provided, use the provided one.
+        (2) if `GOOGLE_API_USE_CLIENT_CERTIFICATE` environment variable is "always", use the
+        default mTLS endpoint; if the environment variable is "never", use the default API
+        endpoint; otherwise if client cert source exists, use the default mTLS endpoint, otherwise
+        use the default API endpoint.
+
+        More details can be found at https://google.aip.dev/auth/4114.
+
+        Args:
+            client_options (google.api_core.client_options.ClientOptions): Custom options for the
+                client. Only the `api_endpoint` and `client_cert_source` properties may be used
+                in this method.
+
+        Returns:
+            Tuple[str, Callable[[], Tuple[bytes, bytes]]]: returns the API endpoint and the
+                client cert source to use.
+
+        Raises:
+            google.auth.exceptions.MutualTLSChannelError: If any errors happen.
+        """
+        return PermissionServiceClient.get_mtls_endpoint_and_cert_source(client_options)  # type: ignore
+
+    @property
+    def transport(self) -> PermissionServiceTransport:
+        """Returns the transport used by the client instance.
+
+        Returns:
+            PermissionServiceTransport: The transport used by the client instance.
+        """
+        return self._client.transport
+
+    @property
+    def api_endpoint(self):
+        """Return the API endpoint used by the client instance.
+
+        Returns:
+            str: The API endpoint used by the client instance.
+        """
+        return self._client._api_endpoint
+
+    @property
+    def universe_domain(self) -> str:
+        """Return the universe domain used by the client instance.
+
+        Returns:
+            str: The universe domain used
+                by the client instance.
+        """
+        return self._client._universe_domain
+
+    get_transport_class = PermissionServiceClient.get_transport_class
+
+    def __init__(
+        self,
+        *,
+        credentials: Optional[ga_credentials.Credentials] = None,
+        transport: Optional[
+            Union[
+                str,
+                PermissionServiceTransport,
+                Callable[..., PermissionServiceTransport],
+            ]
+        ] = "grpc_asyncio",
+        client_options: Optional[ClientOptions] = None,
+        client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
+    ) -> None:
+        """Instantiates the permission service async client.
+
+        Args:
+            credentials (Optional[google.auth.credentials.Credentials]): The
+                authorization credentials to attach to requests. These
+                credentials identify the application to the service; if none
+                are specified, the client will attempt to ascertain the
+                credentials from the environment.
+            transport (Optional[Union[str,PermissionServiceTransport,Callable[..., PermissionServiceTransport]]]):
+                The transport to use, or a Callable that constructs and returns a new transport to use.
+                If a Callable is given, it will be called with the same set of initialization
+                arguments as used in the PermissionServiceTransport constructor.
+                If set to None, a transport is chosen automatically.
+            client_options (Optional[Union[google.api_core.client_options.ClientOptions, dict]]):
+                Custom options for the client.
+
+                1. The ``api_endpoint`` property can be used to override the
+                default endpoint provided by the client when ``transport`` is
+                not explicitly provided. Only if this property is not set and
+                ``transport`` was not explicitly provided, the endpoint is
+                determined by the GOOGLE_API_USE_MTLS_ENDPOINT environment
+                variable, which have one of the following values:
+                "always" (always use the default mTLS endpoint), "never" (always
+                use the default regular endpoint) and "auto" (auto-switch to the
+                default mTLS endpoint if client certificate is present; this is
+                the default value).
+
+                2. If the GOOGLE_API_USE_CLIENT_CERTIFICATE environment variable
+                is "true", then the ``client_cert_source`` property can be used
+                to provide a client certificate for mTLS transport. If
+                not provided, the default SSL client certificate will be used if
+                present. If GOOGLE_API_USE_CLIENT_CERTIFICATE is "false" or not
+                set, no client certificate will be used.
+
+                3. The ``universe_domain`` property can be used to override the
+                default "googleapis.com" universe. Note that ``api_endpoint``
+                property still takes precedence; and ``universe_domain`` is
+                currently not supported for mTLS.
+
+            client_info (google.api_core.gapic_v1.client_info.ClientInfo):
+                The client info used to send a user-agent string along with
+                API requests. If ``None``, then default info will be used.
+                Generally, you only need to set this if you're developing
+                your own client library.
+
+        Raises:
+            google.auth.exceptions.MutualTlsChannelError: If mutual TLS transport
+                creation failed for any reason.
+        """
+        self._client = PermissionServiceClient(
+            credentials=credentials,
+            transport=transport,
+            client_options=client_options,
+            client_info=client_info,
+        )
+
+        if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+            std_logging.DEBUG
+        ):  # pragma: NO COVER
+            _LOGGER.debug(
+                "Created client `google.ai.generativelanguage_v1beta3.PermissionServiceAsyncClient`.",
+                extra={
+                    "serviceName": "google.ai.generativelanguage.v1beta3.PermissionService",
+                    "universeDomain": getattr(
+                        self._client._transport._credentials, "universe_domain", ""
+                    ),
+                    "credentialsType": f"{type(self._client._transport._credentials).__module__}.{type(self._client._transport._credentials).__qualname__}",
+                    "credentialsInfo": getattr(
+                        self.transport._credentials, "get_cred_info", lambda: None
+                    )(),
+                }
+                if hasattr(self._client._transport, "_credentials")
+                else {
+                    "serviceName": "google.ai.generativelanguage.v1beta3.PermissionService",
+                    "credentialsType": None,
+                },
+            )
+
+    async def create_permission(
+        self,
+        request: Optional[
+            Union[permission_service.CreatePermissionRequest, dict]
+        ] = None,
+        *,
+        parent: Optional[str] = None,
+        permission: Optional[gag_permission.Permission] = None,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
+    ) -> gag_permission.Permission:
+        r"""Create a permission to a specific resource.
+
+        .. code-block:: python
+
+            # This snippet has been automatically generated and should be regarded as a
+            # code template only.
+            # It will require modifications to work:
+            # - It may require correct/in-range values for request initialization.
+            # - It may require specifying regional endpoints when creating the service
+            #   client as shown in:
+            #   https://googleapis.dev/python/google-api-core/latest/client_options.html
+            from google.ai import generativelanguage_v1beta3
+
+            async def sample_create_permission():
+                # Create a client
+                client = generativelanguage_v1beta3.PermissionServiceAsyncClient()
+
+                # Initialize request argument(s)
+                request = generativelanguage_v1beta3.CreatePermissionRequest(
+                    parent="parent_value",
+                )
+
+                # Make the request
+                response = await client.create_permission(request=request)
+
+                # Handle the response
+                print(response)
+
+        Args:
+            request (Optional[Union[google.ai.generativelanguage_v1beta3.types.CreatePermissionRequest, dict]]):
+                The request object. Request to create a ``Permission``.
+            parent (:class:`str`):
+                Required. The parent resource of the ``Permission``.
+                Format: tunedModels/{tuned_model}
+
+                This corresponds to the ``parent`` field
+                on the ``request`` instance; if ``request`` is provided, this
+                should not be set.
+            permission (:class:`google.ai.generativelanguage_v1beta3.types.Permission`):
+                Required. The permission to create.
+                This corresponds to the ``permission`` field
+                on the ``request`` instance; if ``request`` is provided, this
+                should not be set.
+            retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                sent along with the request as metadata. Normally, each value must be of type `str`,
+                but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                be of type `bytes`.
+
+        Returns:
+            google.ai.generativelanguage_v1beta3.types.Permission:
+                Permission resource grants user,
+                group or the rest of the world access to
+                the PaLM API resource (e.g. a tuned
+                model, file).
+
+                A role is a collection of permitted
+                operations that allows users to perform
+                specific actions on PaLM API resources.
+                To make them available to users, groups,
+                or service accounts, you assign roles.
+                When you assign a role, you grant
+                permissions that the role contains.
+
+                There are three concentric roles. Each
+                role is a superset of the previous
+                role's permitted operations:
+
+                - reader can use the resource (e.g.
+                  tuned model) for inference
+                - writer has reader's permissions and
+                  additionally can edit and share
+                - owner has writer's permissions and
+                  additionally can delete
+
+        """
+        # Create or coerce a protobuf request object.
+        # - Quick check: If we got a request object, we should *not* have
+        #   gotten any keyword arguments that map to the request.
+        has_flattened_params = any([parent, permission])
+        if request is not None and has_flattened_params:
+            raise ValueError(
+                "If the `request` argument is set, then none of "
+                "the individual field arguments should be set."
+            )
+
+        # - Use the request object if provided (there's no risk of modifying the input as
+        #   there are no flattened fields), or create one.
+        if not isinstance(request, permission_service.CreatePermissionRequest):
+            request = permission_service.CreatePermissionRequest(request)
+
+        # If we have keyword arguments corresponding to fields on the
+        # request, apply these.
+        if parent is not None:
+            request.parent = parent
+        if permission is not None:
+            request.permission = permission
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = self._client._transport._wrapped_methods[
+            self._client._transport.create_permission
+        ]
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)),
+        )
+
+        # Validate the universe domain.
+        self._client._validate_universe_domain()
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    async def get_permission(
+        self,
+        request: Optional[Union[permission_service.GetPermissionRequest, dict]] = None,
+        *,
+        name: Optional[str] = None,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
+    ) -> permission.Permission:
+        r"""Gets information about a specific Permission.
+
+        .. code-block:: python
+
+            # This snippet has been automatically generated and should be regarded as a
+            # code template only.
+            # It will require modifications to work:
+            # - It may require correct/in-range values for request initialization.
+            # - It may require specifying regional endpoints when creating the service
+            #   client as shown in:
+            #   https://googleapis.dev/python/google-api-core/latest/client_options.html
+            from google.ai import generativelanguage_v1beta3
+
+            async def sample_get_permission():
+                # Create a client
+                client = generativelanguage_v1beta3.PermissionServiceAsyncClient()
+
+                # Initialize request argument(s)
+                request = generativelanguage_v1beta3.GetPermissionRequest(
+                    name="name_value",
+                )
+
+                # Make the request
+                response = await client.get_permission(request=request)
+
+                # Handle the response
+                print(response)
+
+        Args:
+            request (Optional[Union[google.ai.generativelanguage_v1beta3.types.GetPermissionRequest, dict]]):
+                The request object. Request for getting information about a specific
+                ``Permission``.
+            name (:class:`str`):
+                Required. The resource name of the permission.
+
+                Format:
+                ``tunedModels/{tuned_model}permissions/{permission}``
+
+                This corresponds to the ``name`` field
+                on the ``request`` instance; if ``request`` is provided, this
+                should not be set.
+            retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                sent along with the request as metadata. Normally, each value must be of type `str`,
+                but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                be of type `bytes`.
+
+        Returns:
+            google.ai.generativelanguage_v1beta3.types.Permission:
+                Permission resource grants user,
+                group or the rest of the world access to
+                the PaLM API resource (e.g. a tuned
+                model, file).
+
+                A role is a collection of permitted
+                operations that allows users to perform
+                specific actions on PaLM API resources.
+                To make them available to users, groups,
+                or service accounts, you assign roles.
+                When you assign a role, you grant
+                permissions that the role contains.
+
+                There are three concentric roles. Each
+                role is a superset of the previous
+                role's permitted operations:
+
+                - reader can use the resource (e.g.
+                  tuned model) for inference
+                - writer has reader's permissions and
+                  additionally can edit and share
+                - owner has writer's permissions and
+                  additionally can delete
+
+        """
+        # Create or coerce a protobuf request object.
+        # - Quick check: If we got a request object, we should *not* have
+        #   gotten any keyword arguments that map to the request.
+        has_flattened_params = any([name])
+        if request is not None and has_flattened_params:
+            raise ValueError(
+                "If the `request` argument is set, then none of "
+                "the individual field arguments should be set."
+            )
+
+        # - Use the request object if provided (there's no risk of modifying the input as
+        #   there are no flattened fields), or create one.
+        if not isinstance(request, permission_service.GetPermissionRequest):
+            request = permission_service.GetPermissionRequest(request)
+
+        # If we have keyword arguments corresponding to fields on the
+        # request, apply these.
+        if name is not None:
+            request.name = name
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = self._client._transport._wrapped_methods[
+            self._client._transport.get_permission
+        ]
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Validate the universe domain.
+        self._client._validate_universe_domain()
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    async def list_permissions(
+        self,
+        request: Optional[
+            Union[permission_service.ListPermissionsRequest, dict]
+        ] = None,
+        *,
+        parent: Optional[str] = None,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
+    ) -> pagers.ListPermissionsAsyncPager:
+        r"""Lists permissions for the specific resource.
+
+        .. code-block:: python
+
+            # This snippet has been automatically generated and should be regarded as a
+            # code template only.
+            # It will require modifications to work:
+            # - It may require correct/in-range values for request initialization.
+            # - It may require specifying regional endpoints when creating the service
+            #   client as shown in:
+            #   https://googleapis.dev/python/google-api-core/latest/client_options.html
+            from google.ai import generativelanguage_v1beta3
+
+            async def sample_list_permissions():
+                # Create a client
+                client = generativelanguage_v1beta3.PermissionServiceAsyncClient()
+
+                # Initialize request argument(s)
+                request = generativelanguage_v1beta3.ListPermissionsRequest(
+                    parent="parent_value",
+                )
+
+                # Make the request
+                page_result = client.list_permissions(request=request)
+
+                # Handle the response
+                async for response in page_result:
+                    print(response)
+
+        Args:
+            request (Optional[Union[google.ai.generativelanguage_v1beta3.types.ListPermissionsRequest, dict]]):
+                The request object. Request for listing permissions.
+            parent (:class:`str`):
+                Required. The parent resource of the permissions.
+                Format: tunedModels/{tuned_model}
+
+                This corresponds to the ``parent`` field
+                on the ``request`` instance; if ``request`` is provided, this
+                should not be set.
+            retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                sent along with the request as metadata. Normally, each value must be of type `str`,
+                but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                be of type `bytes`.
+
+        Returns:
+            google.ai.generativelanguage_v1beta3.services.permission_service.pagers.ListPermissionsAsyncPager:
+                Response from ListPermissions containing a paginated list of
+                   permissions.
+
+                Iterating over this object will yield results and
+                resolve additional pages automatically.
+
+        """
+        # Create or coerce a protobuf request object.
+        # - Quick check: If we got a request object, we should *not* have
+        #   gotten any keyword arguments that map to the request.
+        has_flattened_params = any([parent])
+        if request is not None and has_flattened_params:
+            raise ValueError(
+                "If the `request` argument is set, then none of "
+                "the individual field arguments should be set."
+            )
+
+        # - Use the request object if provided (there's no risk of modifying the input as
+        #   there are no flattened fields), or create one.
+        if not isinstance(request, permission_service.ListPermissionsRequest):
+            request = permission_service.ListPermissionsRequest(request)
+
+        # If we have keyword arguments corresponding to fields on the
+        # request, apply these.
+        if parent is not None:
+            request.parent = parent
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = self._client._transport._wrapped_methods[
+            self._client._transport.list_permissions
+        ]
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)),
+        )
+
+        # Validate the universe domain.
+        self._client._validate_universe_domain()
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # This method is paged; wrap the response in a pager, which provides
+        # an `__aiter__` convenience method.
+        response = pagers.ListPermissionsAsyncPager(
+            method=rpc,
+            request=request,
+            response=response,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    async def update_permission(
+        self,
+        request: Optional[
+            Union[permission_service.UpdatePermissionRequest, dict]
+        ] = None,
+        *,
+        permission: Optional[gag_permission.Permission] = None,
+        update_mask: Optional[field_mask_pb2.FieldMask] = None,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
+    ) -> gag_permission.Permission:
+        r"""Updates the permission.
+
+        .. code-block:: python
+
+            # This snippet has been automatically generated and should be regarded as a
+            # code template only.
+            # It will require modifications to work:
+            # - It may require correct/in-range values for request initialization.
+            # - It may require specifying regional endpoints when creating the service
+            #   client as shown in:
+            #   https://googleapis.dev/python/google-api-core/latest/client_options.html
+            from google.ai import generativelanguage_v1beta3
+
+            async def sample_update_permission():
+                # Create a client
+                client = generativelanguage_v1beta3.PermissionServiceAsyncClient()
+
+                # Initialize request argument(s)
+                request = generativelanguage_v1beta3.UpdatePermissionRequest(
+                )
+
+                # Make the request
+                response = await client.update_permission(request=request)
+
+                # Handle the response
+                print(response)
+
+        Args:
+            request (Optional[Union[google.ai.generativelanguage_v1beta3.types.UpdatePermissionRequest, dict]]):
+                The request object. Request to update the ``Permission``.
+            permission (:class:`google.ai.generativelanguage_v1beta3.types.Permission`):
+                Required. The permission to update.
+
+                The permission's ``name`` field is used to identify the
+                permission to update.
+
+                This corresponds to the ``permission`` field
+                on the ``request`` instance; if ``request`` is provided, this
+                should not be set.
+            update_mask (:class:`google.protobuf.field_mask_pb2.FieldMask`):
+                Required. The list of fields to update. Accepted ones:
+
+                -  role (``Permission.role`` field)
+
+                This corresponds to the ``update_mask`` field
+                on the ``request`` instance; if ``request`` is provided, this
+                should not be set.
+            retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                sent along with the request as metadata. Normally, each value must be of type `str`,
+                but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                be of type `bytes`.
+
+        Returns:
+            google.ai.generativelanguage_v1beta3.types.Permission:
+                Permission resource grants user,
+                group or the rest of the world access to
+                the PaLM API resource (e.g. a tuned
+                model, file).
+
+                A role is a collection of permitted
+                operations that allows users to perform
+                specific actions on PaLM API resources.
+                To make them available to users, groups,
+                or service accounts, you assign roles.
+                When you assign a role, you grant
+                permissions that the role contains.
+
+                There are three concentric roles. Each
+                role is a superset of the previous
+                role's permitted operations:
+
+                - reader can use the resource (e.g.
+                  tuned model) for inference
+                - writer has reader's permissions and
+                  additionally can edit and share
+                - owner has writer's permissions and
+                  additionally can delete
+
+        """
+        # Create or coerce a protobuf request object.
+        # - Quick check: If we got a request object, we should *not* have
+        #   gotten any keyword arguments that map to the request.
+        has_flattened_params = any([permission, update_mask])
+        if request is not None and has_flattened_params:
+            raise ValueError(
+                "If the `request` argument is set, then none of "
+                "the individual field arguments should be set."
+            )
+
+        # - Use the request object if provided (there's no risk of modifying the input as
+        #   there are no flattened fields), or create one.
+        if not isinstance(request, permission_service.UpdatePermissionRequest):
+            request = permission_service.UpdatePermissionRequest(request)
+
+        # If we have keyword arguments corresponding to fields on the
+        # request, apply these.
+        if permission is not None:
+            request.permission = permission
+        if update_mask is not None:
+            request.update_mask = update_mask
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = self._client._transport._wrapped_methods[
+            self._client._transport.update_permission
+        ]
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata(
+                (("permission.name", request.permission.name),)
+            ),
+        )
+
+        # Validate the universe domain.
+        self._client._validate_universe_domain()
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    async def delete_permission(
+        self,
+        request: Optional[
+            Union[permission_service.DeletePermissionRequest, dict]
+        ] = None,
+        *,
+        name: Optional[str] = None,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
+    ) -> None:
+        r"""Deletes the permission.
+
+        .. code-block:: python
+
+            # This snippet has been automatically generated and should be regarded as a
+            # code template only.
+            # It will require modifications to work:
+            # - It may require correct/in-range values for request initialization.
+            # - It may require specifying regional endpoints when creating the service
+            #   client as shown in:
+            #   https://googleapis.dev/python/google-api-core/latest/client_options.html
+            from google.ai import generativelanguage_v1beta3
+
+            async def sample_delete_permission():
+                # Create a client
+                client = generativelanguage_v1beta3.PermissionServiceAsyncClient()
+
+                # Initialize request argument(s)
+                request = generativelanguage_v1beta3.DeletePermissionRequest(
+                    name="name_value",
+                )
+
+                # Make the request
+                await client.delete_permission(request=request)
+
+        Args:
+            request (Optional[Union[google.ai.generativelanguage_v1beta3.types.DeletePermissionRequest, dict]]):
+                The request object. Request to delete the ``Permission``.
+            name (:class:`str`):
+                Required. The resource name of the permission. Format:
+                ``tunedModels/{tuned_model}/permissions/{permission}``
+
+                This corresponds to the ``name`` field
+                on the ``request`` instance; if ``request`` is provided, this
+                should not be set.
+            retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                sent along with the request as metadata. Normally, each value must be of type `str`,
+                but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                be of type `bytes`.
+        """
+        # Create or coerce a protobuf request object.
+        # - Quick check: If we got a request object, we should *not* have
+        #   gotten any keyword arguments that map to the request.
+        has_flattened_params = any([name])
+        if request is not None and has_flattened_params:
+            raise ValueError(
+                "If the `request` argument is set, then none of "
+                "the individual field arguments should be set."
+            )
+
+        # - Use the request object if provided (there's no risk of modifying the input as
+        #   there are no flattened fields), or create one.
+        if not isinstance(request, permission_service.DeletePermissionRequest):
+            request = permission_service.DeletePermissionRequest(request)
+
+        # If we have keyword arguments corresponding to fields on the
+        # request, apply these.
+        if name is not None:
+            request.name = name
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = self._client._transport._wrapped_methods[
+            self._client._transport.delete_permission
+        ]
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Validate the universe domain.
+        self._client._validate_universe_domain()
+
+        # Send the request.
+        await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    async def transfer_ownership(
+        self,
+        request: Optional[
+            Union[permission_service.TransferOwnershipRequest, dict]
+        ] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
+    ) -> permission_service.TransferOwnershipResponse:
+        r"""Transfers ownership of the tuned model.
+        This is the only way to change ownership of the tuned
+        model. The current owner will be downgraded to writer
+        role.
+
+        .. code-block:: python
+
+            # This snippet has been automatically generated and should be regarded as a
+            # code template only.
+            # It will require modifications to work:
+            # - It may require correct/in-range values for request initialization.
+            # - It may require specifying regional endpoints when creating the service
+            #   client as shown in:
+            #   https://googleapis.dev/python/google-api-core/latest/client_options.html
+            from google.ai import generativelanguage_v1beta3
+
+            async def sample_transfer_ownership():
+                # Create a client
+                client = generativelanguage_v1beta3.PermissionServiceAsyncClient()
+
+                # Initialize request argument(s)
+                request = generativelanguage_v1beta3.TransferOwnershipRequest(
+                    name="name_value",
+                    email_address="email_address_value",
+                )
+
+                # Make the request
+                response = await client.transfer_ownership(request=request)
+
+                # Handle the response
+                print(response)
+
+        Args:
+            request (Optional[Union[google.ai.generativelanguage_v1beta3.types.TransferOwnershipRequest, dict]]):
+                The request object. Request to transfer the ownership of
+                the tuned model.
+            retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                sent along with the request as metadata. Normally, each value must be of type `str`,
+                but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                be of type `bytes`.
+
+        Returns:
+            google.ai.generativelanguage_v1beta3.types.TransferOwnershipResponse:
+                Response from TransferOwnership.
+        """
+        # Create or coerce a protobuf request object.
+        # - Use the request object if provided (there's no risk of modifying the input as
+        #   there are no flattened fields), or create one.
+        if not isinstance(request, permission_service.TransferOwnershipRequest):
+            request = permission_service.TransferOwnershipRequest(request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = self._client._transport._wrapped_methods[
+            self._client._transport.transfer_ownership
+        ]
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Validate the universe domain.
+        self._client._validate_universe_domain()
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    async def __aenter__(self) -> "PermissionServiceAsyncClient":
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):
+        await self.transport.close()
+
+
+DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
+    gapic_version=package_version.__version__
+)
+
+
+__all__ = ("PermissionServiceAsyncClient",)

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/services/permission_service/client.py

@@ -0,0 +1,1433 @@
+# -*- coding: utf-8 -*-
+# 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 collections import OrderedDict
+import logging as std_logging
+import os
+import re
+from typing import (
+    Callable,
+    Dict,
+    Mapping,
+    MutableMapping,
+    MutableSequence,
+    Optional,
+    Sequence,
+    Tuple,
+    Type,
+    Union,
+    cast,
+)
+import warnings
+
+from google.api_core import client_options as client_options_lib
+from google.api_core import exceptions as core_exceptions
+from google.api_core import gapic_v1
+from google.api_core import retry as retries
+from google.auth import credentials as ga_credentials  # type: ignore
+from google.auth.exceptions import MutualTLSChannelError  # type: ignore
+from google.auth.transport import mtls  # type: ignore
+from google.auth.transport.grpc import SslCredentials  # type: ignore
+from google.oauth2 import service_account  # type: ignore
+
+from google.ai.generativelanguage_v1beta3 import gapic_version as package_version
+
+try:
+    OptionalRetry = Union[retries.Retry, gapic_v1.method._MethodDefault, None]
+except AttributeError:  # pragma: NO COVER
+    OptionalRetry = Union[retries.Retry, object, None]  # type: ignore
+
+try:
+    from google.api_core import client_logging  # type: ignore
+
+    CLIENT_LOGGING_SUPPORTED = True  # pragma: NO COVER
+except ImportError:  # pragma: NO COVER
+    CLIENT_LOGGING_SUPPORTED = False
+
+_LOGGER = std_logging.getLogger(__name__)
+
+from google.longrunning import operations_pb2  # type: ignore
+from google.protobuf import field_mask_pb2  # type: ignore
+
+from google.ai.generativelanguage_v1beta3.services.permission_service import pagers
+from google.ai.generativelanguage_v1beta3.types import permission as gag_permission
+from google.ai.generativelanguage_v1beta3.types import permission
+from google.ai.generativelanguage_v1beta3.types import permission_service
+
+from .transports.base import DEFAULT_CLIENT_INFO, PermissionServiceTransport
+from .transports.grpc import PermissionServiceGrpcTransport
+from .transports.grpc_asyncio import PermissionServiceGrpcAsyncIOTransport
+from .transports.rest import PermissionServiceRestTransport
+
+
+class PermissionServiceClientMeta(type):
+    """Metaclass for the PermissionService client.
+
+    This provides class-level methods for building and retrieving
+    support objects (e.g. transport) without polluting the client instance
+    objects.
+    """
+
+    _transport_registry = (
+        OrderedDict()
+    )  # type: Dict[str, Type[PermissionServiceTransport]]
+    _transport_registry["grpc"] = PermissionServiceGrpcTransport
+    _transport_registry["grpc_asyncio"] = PermissionServiceGrpcAsyncIOTransport
+    _transport_registry["rest"] = PermissionServiceRestTransport
+
+    def get_transport_class(
+        cls,
+        label: Optional[str] = None,
+    ) -> Type[PermissionServiceTransport]:
+        """Returns an appropriate transport class.
+
+        Args:
+            label: The name of the desired transport. If none is
+                provided, then the first transport in the registry is used.
+
+        Returns:
+            The transport class to use.
+        """
+        # If a specific transport is requested, return that one.
+        if label:
+            return cls._transport_registry[label]
+
+        # No transport is requested; return the default (that is, the first one
+        # in the dictionary).
+        return next(iter(cls._transport_registry.values()))
+
+
+class PermissionServiceClient(metaclass=PermissionServiceClientMeta):
+    """Provides methods for managing permissions to PaLM API
+    resources.
+    """
+
+    @staticmethod
+    def _get_default_mtls_endpoint(api_endpoint):
+        """Converts api endpoint to mTLS endpoint.
+
+        Convert "*.sandbox.googleapis.com" and "*.googleapis.com" to
+        "*.mtls.sandbox.googleapis.com" and "*.mtls.googleapis.com" respectively.
+        Args:
+            api_endpoint (Optional[str]): the api endpoint to convert.
+        Returns:
+            str: converted mTLS api endpoint.
+        """
+        if not api_endpoint:
+            return api_endpoint
+
+        mtls_endpoint_re = re.compile(
+            r"(?P<name>[^.]+)(?P<mtls>\.mtls)?(?P<sandbox>\.sandbox)?(?P<googledomain>\.googleapis\.com)?"
+        )
+
+        m = mtls_endpoint_re.match(api_endpoint)
+        name, mtls, sandbox, googledomain = m.groups()
+        if mtls or not googledomain:
+            return api_endpoint
+
+        if sandbox:
+            return api_endpoint.replace(
+                "sandbox.googleapis.com", "mtls.sandbox.googleapis.com"
+            )
+
+        return api_endpoint.replace(".googleapis.com", ".mtls.googleapis.com")
+
+    # Note: DEFAULT_ENDPOINT is deprecated. Use _DEFAULT_ENDPOINT_TEMPLATE instead.
+    DEFAULT_ENDPOINT = "generativelanguage.googleapis.com"
+    DEFAULT_MTLS_ENDPOINT = _get_default_mtls_endpoint.__func__(  # type: ignore
+        DEFAULT_ENDPOINT
+    )
+
+    _DEFAULT_ENDPOINT_TEMPLATE = "generativelanguage.{UNIVERSE_DOMAIN}"
+    _DEFAULT_UNIVERSE = "googleapis.com"
+
+    @classmethod
+    def from_service_account_info(cls, info: dict, *args, **kwargs):
+        """Creates an instance of this client using the provided credentials
+            info.
+
+        Args:
+            info (dict): The service account private key info.
+            args: Additional arguments to pass to the constructor.
+            kwargs: Additional arguments to pass to the constructor.
+
+        Returns:
+            PermissionServiceClient: The constructed client.
+        """
+        credentials = service_account.Credentials.from_service_account_info(info)
+        kwargs["credentials"] = credentials
+        return cls(*args, **kwargs)
+
+    @classmethod
+    def from_service_account_file(cls, filename: str, *args, **kwargs):
+        """Creates an instance of this client using the provided credentials
+            file.
+
+        Args:
+            filename (str): The path to the service account private key json
+                file.
+            args: Additional arguments to pass to the constructor.
+            kwargs: Additional arguments to pass to the constructor.
+
+        Returns:
+            PermissionServiceClient: The constructed client.
+        """
+        credentials = service_account.Credentials.from_service_account_file(filename)
+        kwargs["credentials"] = credentials
+        return cls(*args, **kwargs)
+
+    from_service_account_json = from_service_account_file
+
+    @property
+    def transport(self) -> PermissionServiceTransport:
+        """Returns the transport used by the client instance.
+
+        Returns:
+            PermissionServiceTransport: The transport used by the client
+                instance.
+        """
+        return self._transport
+
+    @staticmethod
+    def permission_path(
+        tuned_model: str,
+        permission: str,
+    ) -> str:
+        """Returns a fully-qualified permission string."""
+        return "tunedModels/{tuned_model}/permissions/{permission}".format(
+            tuned_model=tuned_model,
+            permission=permission,
+        )
+
+    @staticmethod
+    def parse_permission_path(path: str) -> Dict[str, str]:
+        """Parses a permission path into its component segments."""
+        m = re.match(
+            r"^tunedModels/(?P<tuned_model>.+?)/permissions/(?P<permission>.+?)$", path
+        )
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def tuned_model_path(
+        tuned_model: str,
+    ) -> str:
+        """Returns a fully-qualified tuned_model string."""
+        return "tunedModels/{tuned_model}".format(
+            tuned_model=tuned_model,
+        )
+
+    @staticmethod
+    def parse_tuned_model_path(path: str) -> Dict[str, str]:
+        """Parses a tuned_model path into its component segments."""
+        m = re.match(r"^tunedModels/(?P<tuned_model>.+?)$", path)
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def common_billing_account_path(
+        billing_account: str,
+    ) -> str:
+        """Returns a fully-qualified billing_account string."""
+        return "billingAccounts/{billing_account}".format(
+            billing_account=billing_account,
+        )
+
+    @staticmethod
+    def parse_common_billing_account_path(path: str) -> Dict[str, str]:
+        """Parse a billing_account path into its component segments."""
+        m = re.match(r"^billingAccounts/(?P<billing_account>.+?)$", path)
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def common_folder_path(
+        folder: str,
+    ) -> str:
+        """Returns a fully-qualified folder string."""
+        return "folders/{folder}".format(
+            folder=folder,
+        )
+
+    @staticmethod
+    def parse_common_folder_path(path: str) -> Dict[str, str]:
+        """Parse a folder path into its component segments."""
+        m = re.match(r"^folders/(?P<folder>.+?)$", path)
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def common_organization_path(
+        organization: str,
+    ) -> str:
+        """Returns a fully-qualified organization string."""
+        return "organizations/{organization}".format(
+            organization=organization,
+        )
+
+    @staticmethod
+    def parse_common_organization_path(path: str) -> Dict[str, str]:
+        """Parse a organization path into its component segments."""
+        m = re.match(r"^organizations/(?P<organization>.+?)$", path)
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def common_project_path(
+        project: str,
+    ) -> str:
+        """Returns a fully-qualified project string."""
+        return "projects/{project}".format(
+            project=project,
+        )
+
+    @staticmethod
+    def parse_common_project_path(path: str) -> Dict[str, str]:
+        """Parse a project path into its component segments."""
+        m = re.match(r"^projects/(?P<project>.+?)$", path)
+        return m.groupdict() if m else {}
+
+    @staticmethod
+    def common_location_path(
+        project: str,
+        location: str,
+    ) -> str:
+        """Returns a fully-qualified location string."""
+        return "projects/{project}/locations/{location}".format(
+            project=project,
+            location=location,
+        )
+
+    @staticmethod
+    def parse_common_location_path(path: str) -> Dict[str, str]:
+        """Parse a location path into its component segments."""
+        m = re.match(r"^projects/(?P<project>.+?)/locations/(?P<location>.+?)$", path)
+        return m.groupdict() if m else {}
+
+    @classmethod
+    def get_mtls_endpoint_and_cert_source(
+        cls, client_options: Optional[client_options_lib.ClientOptions] = None
+    ):
+        """Deprecated. Return the API endpoint and client cert source for mutual TLS.
+
+        The client cert source is determined in the following order:
+        (1) if `GOOGLE_API_USE_CLIENT_CERTIFICATE` environment variable is not "true", the
+        client cert source is None.
+        (2) if `client_options.client_cert_source` is provided, use the provided one; if the
+        default client cert source exists, use the default one; otherwise the client cert
+        source is None.
+
+        The API endpoint is determined in the following order:
+        (1) if `client_options.api_endpoint` if provided, use the provided one.
+        (2) if `GOOGLE_API_USE_CLIENT_CERTIFICATE` environment variable is "always", use the
+        default mTLS endpoint; if the environment variable is "never", use the default API
+        endpoint; otherwise if client cert source exists, use the default mTLS endpoint, otherwise
+        use the default API endpoint.
+
+        More details can be found at https://google.aip.dev/auth/4114.
+
+        Args:
+            client_options (google.api_core.client_options.ClientOptions): Custom options for the
+                client. Only the `api_endpoint` and `client_cert_source` properties may be used
+                in this method.
+
+        Returns:
+            Tuple[str, Callable[[], Tuple[bytes, bytes]]]: returns the API endpoint and the
+                client cert source to use.
+
+        Raises:
+            google.auth.exceptions.MutualTLSChannelError: If any errors happen.
+        """
+
+        warnings.warn(
+            "get_mtls_endpoint_and_cert_source is deprecated. Use the api_endpoint property instead.",
+            DeprecationWarning,
+        )
+        if client_options is None:
+            client_options = client_options_lib.ClientOptions()
+        use_client_cert = os.getenv("GOOGLE_API_USE_CLIENT_CERTIFICATE", "false")
+        use_mtls_endpoint = os.getenv("GOOGLE_API_USE_MTLS_ENDPOINT", "auto")
+        if use_client_cert not in ("true", "false"):
+            raise ValueError(
+                "Environment variable `GOOGLE_API_USE_CLIENT_CERTIFICATE` must be either `true` or `false`"
+            )
+        if use_mtls_endpoint not in ("auto", "never", "always"):
+            raise MutualTLSChannelError(
+                "Environment variable `GOOGLE_API_USE_MTLS_ENDPOINT` must be `never`, `auto` or `always`"
+            )
+
+        # Figure out the client cert source to use.
+        client_cert_source = None
+        if use_client_cert == "true":
+            if client_options.client_cert_source:
+                client_cert_source = client_options.client_cert_source
+            elif mtls.has_default_client_cert_source():
+                client_cert_source = mtls.default_client_cert_source()
+
+        # Figure out which api endpoint to use.
+        if client_options.api_endpoint is not None:
+            api_endpoint = client_options.api_endpoint
+        elif use_mtls_endpoint == "always" or (
+            use_mtls_endpoint == "auto" and client_cert_source
+        ):
+            api_endpoint = cls.DEFAULT_MTLS_ENDPOINT
+        else:
+            api_endpoint = cls.DEFAULT_ENDPOINT
+
+        return api_endpoint, client_cert_source
+
+    @staticmethod
+    def _read_environment_variables():
+        """Returns the environment variables used by the client.
+
+        Returns:
+            Tuple[bool, str, str]: returns the GOOGLE_API_USE_CLIENT_CERTIFICATE,
+            GOOGLE_API_USE_MTLS_ENDPOINT, and GOOGLE_CLOUD_UNIVERSE_DOMAIN environment variables.
+
+        Raises:
+            ValueError: If GOOGLE_API_USE_CLIENT_CERTIFICATE is not
+                any of ["true", "false"].
+            google.auth.exceptions.MutualTLSChannelError: If GOOGLE_API_USE_MTLS_ENDPOINT
+                is not any of ["auto", "never", "always"].
+        """
+        use_client_cert = os.getenv(
+            "GOOGLE_API_USE_CLIENT_CERTIFICATE", "false"
+        ).lower()
+        use_mtls_endpoint = os.getenv("GOOGLE_API_USE_MTLS_ENDPOINT", "auto").lower()
+        universe_domain_env = os.getenv("GOOGLE_CLOUD_UNIVERSE_DOMAIN")
+        if use_client_cert not in ("true", "false"):
+            raise ValueError(
+                "Environment variable `GOOGLE_API_USE_CLIENT_CERTIFICATE` must be either `true` or `false`"
+            )
+        if use_mtls_endpoint not in ("auto", "never", "always"):
+            raise MutualTLSChannelError(
+                "Environment variable `GOOGLE_API_USE_MTLS_ENDPOINT` must be `never`, `auto` or `always`"
+            )
+        return use_client_cert == "true", use_mtls_endpoint, universe_domain_env
+
+    @staticmethod
+    def _get_client_cert_source(provided_cert_source, use_cert_flag):
+        """Return the client cert source to be used by the client.
+
+        Args:
+            provided_cert_source (bytes): The client certificate source provided.
+            use_cert_flag (bool): A flag indicating whether to use the client certificate.
+
+        Returns:
+            bytes or None: The client cert source to be used by the client.
+        """
+        client_cert_source = None
+        if use_cert_flag:
+            if provided_cert_source:
+                client_cert_source = provided_cert_source
+            elif mtls.has_default_client_cert_source():
+                client_cert_source = mtls.default_client_cert_source()
+        return client_cert_source
+
+    @staticmethod
+    def _get_api_endpoint(
+        api_override, client_cert_source, universe_domain, use_mtls_endpoint
+    ):
+        """Return the API endpoint used by the client.
+
+        Args:
+            api_override (str): The API endpoint override. If specified, this is always
+                the return value of this function and the other arguments are not used.
+            client_cert_source (bytes): The client certificate source used by the client.
+            universe_domain (str): The universe domain used by the client.
+            use_mtls_endpoint (str): How to use the mTLS endpoint, which depends also on the other parameters.
+                Possible values are "always", "auto", or "never".
+
+        Returns:
+            str: The API endpoint to be used by the client.
+        """
+        if api_override is not None:
+            api_endpoint = api_override
+        elif use_mtls_endpoint == "always" or (
+            use_mtls_endpoint == "auto" and client_cert_source
+        ):
+            _default_universe = PermissionServiceClient._DEFAULT_UNIVERSE
+            if universe_domain != _default_universe:
+                raise MutualTLSChannelError(
+                    f"mTLS is not supported in any universe other than {_default_universe}."
+                )
+            api_endpoint = PermissionServiceClient.DEFAULT_MTLS_ENDPOINT
+        else:
+            api_endpoint = PermissionServiceClient._DEFAULT_ENDPOINT_TEMPLATE.format(
+                UNIVERSE_DOMAIN=universe_domain
+            )
+        return api_endpoint
+
+    @staticmethod
+    def _get_universe_domain(
+        client_universe_domain: Optional[str], universe_domain_env: Optional[str]
+    ) -> str:
+        """Return the universe domain used by the client.
+
+        Args:
+            client_universe_domain (Optional[str]): The universe domain configured via the client options.
+            universe_domain_env (Optional[str]): The universe domain configured via the "GOOGLE_CLOUD_UNIVERSE_DOMAIN" environment variable.
+
+        Returns:
+            str: The universe domain to be used by the client.
+
+        Raises:
+            ValueError: If the universe domain is an empty string.
+        """
+        universe_domain = PermissionServiceClient._DEFAULT_UNIVERSE
+        if client_universe_domain is not None:
+            universe_domain = client_universe_domain
+        elif universe_domain_env is not None:
+            universe_domain = universe_domain_env
+        if len(universe_domain.strip()) == 0:
+            raise ValueError("Universe Domain cannot be an empty string.")
+        return universe_domain
+
+    def _validate_universe_domain(self):
+        """Validates client's and credentials' universe domains are consistent.
+
+        Returns:
+            bool: True iff the configured universe domain is valid.
+
+        Raises:
+            ValueError: If the configured universe domain is not valid.
+        """
+
+        # NOTE (b/349488459): universe validation is disabled until further notice.
+        return True
+
+    @property
+    def api_endpoint(self):
+        """Return the API endpoint used by the client instance.
+
+        Returns:
+            str: The API endpoint used by the client instance.
+        """
+        return self._api_endpoint
+
+    @property
+    def universe_domain(self) -> str:
+        """Return the universe domain used by the client instance.
+
+        Returns:
+            str: The universe domain used by the client instance.
+        """
+        return self._universe_domain
+
+    def __init__(
+        self,
+        *,
+        credentials: Optional[ga_credentials.Credentials] = None,
+        transport: Optional[
+            Union[
+                str,
+                PermissionServiceTransport,
+                Callable[..., PermissionServiceTransport],
+            ]
+        ] = None,
+        client_options: Optional[Union[client_options_lib.ClientOptions, dict]] = None,
+        client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
+    ) -> None:
+        """Instantiates the permission service client.
+
+        Args:
+            credentials (Optional[google.auth.credentials.Credentials]): The
+                authorization credentials to attach to requests. These
+                credentials identify the application to the service; if none
+                are specified, the client will attempt to ascertain the
+                credentials from the environment.
+            transport (Optional[Union[str,PermissionServiceTransport,Callable[..., PermissionServiceTransport]]]):
+                The transport to use, or a Callable that constructs and returns a new transport.
+                If a Callable is given, it will be called with the same set of initialization
+                arguments as used in the PermissionServiceTransport constructor.
+                If set to None, a transport is chosen automatically.
+            client_options (Optional[Union[google.api_core.client_options.ClientOptions, dict]]):
+                Custom options for the client.
+
+                1. The ``api_endpoint`` property can be used to override the
+                default endpoint provided by the client when ``transport`` is
+                not explicitly provided. Only if this property is not set and
+                ``transport`` was not explicitly provided, the endpoint is
+                determined by the GOOGLE_API_USE_MTLS_ENDPOINT environment
+                variable, which have one of the following values:
+                "always" (always use the default mTLS endpoint), "never" (always
+                use the default regular endpoint) and "auto" (auto-switch to the
+                default mTLS endpoint if client certificate is present; this is
+                the default value).
+
+                2. If the GOOGLE_API_USE_CLIENT_CERTIFICATE environment variable
+                is "true", then the ``client_cert_source`` property can be used
+                to provide a client certificate for mTLS transport. If
+                not provided, the default SSL client certificate will be used if
+                present. If GOOGLE_API_USE_CLIENT_CERTIFICATE is "false" or not
+                set, no client certificate will be used.
+
+                3. The ``universe_domain`` property can be used to override the
+                default "googleapis.com" universe. Note that the ``api_endpoint``
+                property still takes precedence; and ``universe_domain`` is
+                currently not supported for mTLS.
+
+            client_info (google.api_core.gapic_v1.client_info.ClientInfo):
+                The client info used to send a user-agent string along with
+                API requests. If ``None``, then default info will be used.
+                Generally, you only need to set this if you're developing
+                your own client library.
+
+        Raises:
+            google.auth.exceptions.MutualTLSChannelError: If mutual TLS transport
+                creation failed for any reason.
+        """
+        self._client_options = client_options
+        if isinstance(self._client_options, dict):
+            self._client_options = client_options_lib.from_dict(self._client_options)
+        if self._client_options is None:
+            self._client_options = client_options_lib.ClientOptions()
+        self._client_options = cast(
+            client_options_lib.ClientOptions, self._client_options
+        )
+
+        universe_domain_opt = getattr(self._client_options, "universe_domain", None)
+
+        (
+            self._use_client_cert,
+            self._use_mtls_endpoint,
+            self._universe_domain_env,
+        ) = PermissionServiceClient._read_environment_variables()
+        self._client_cert_source = PermissionServiceClient._get_client_cert_source(
+            self._client_options.client_cert_source, self._use_client_cert
+        )
+        self._universe_domain = PermissionServiceClient._get_universe_domain(
+            universe_domain_opt, self._universe_domain_env
+        )
+        self._api_endpoint = None  # updated below, depending on `transport`
+
+        # Initialize the universe domain validation.
+        self._is_universe_domain_valid = False
+
+        if CLIENT_LOGGING_SUPPORTED:  # pragma: NO COVER
+            # Setup logging.
+            client_logging.initialize_logging()
+
+        api_key_value = getattr(self._client_options, "api_key", None)
+        if api_key_value and credentials:
+            raise ValueError(
+                "client_options.api_key and credentials are mutually exclusive"
+            )
+
+        # Save or instantiate the transport.
+        # Ordinarily, we provide the transport, but allowing a custom transport
+        # instance provides an extensibility point for unusual situations.
+        transport_provided = isinstance(transport, PermissionServiceTransport)
+        if transport_provided:
+            # transport is a PermissionServiceTransport instance.
+            if credentials or self._client_options.credentials_file or api_key_value:
+                raise ValueError(
+                    "When providing a transport instance, "
+                    "provide its credentials directly."
+                )
+            if self._client_options.scopes:
+                raise ValueError(
+                    "When providing a transport instance, provide its scopes "
+                    "directly."
+                )
+            self._transport = cast(PermissionServiceTransport, transport)
+            self._api_endpoint = self._transport.host
+
+        self._api_endpoint = (
+            self._api_endpoint
+            or PermissionServiceClient._get_api_endpoint(
+                self._client_options.api_endpoint,
+                self._client_cert_source,
+                self._universe_domain,
+                self._use_mtls_endpoint,
+            )
+        )
+
+        if not transport_provided:
+            import google.auth._default  # type: ignore
+
+            if api_key_value and hasattr(
+                google.auth._default, "get_api_key_credentials"
+            ):
+                credentials = google.auth._default.get_api_key_credentials(
+                    api_key_value
+                )
+
+            transport_init: Union[
+                Type[PermissionServiceTransport],
+                Callable[..., PermissionServiceTransport],
+            ] = (
+                PermissionServiceClient.get_transport_class(transport)
+                if isinstance(transport, str) or transport is None
+                else cast(Callable[..., PermissionServiceTransport], transport)
+            )
+            # initialize with the provided callable or the passed in class
+            self._transport = transport_init(
+                credentials=credentials,
+                credentials_file=self._client_options.credentials_file,
+                host=self._api_endpoint,
+                scopes=self._client_options.scopes,
+                client_cert_source_for_mtls=self._client_cert_source,
+                quota_project_id=self._client_options.quota_project_id,
+                client_info=client_info,
+                always_use_jwt_access=True,
+                api_audience=self._client_options.api_audience,
+            )
+
+        if "async" not in str(self._transport):
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                std_logging.DEBUG
+            ):  # pragma: NO COVER
+                _LOGGER.debug(
+                    "Created client `google.ai.generativelanguage_v1beta3.PermissionServiceClient`.",
+                    extra={
+                        "serviceName": "google.ai.generativelanguage.v1beta3.PermissionService",
+                        "universeDomain": getattr(
+                            self._transport._credentials, "universe_domain", ""
+                        ),
+                        "credentialsType": f"{type(self._transport._credentials).__module__}.{type(self._transport._credentials).__qualname__}",
+                        "credentialsInfo": getattr(
+                            self.transport._credentials, "get_cred_info", lambda: None
+                        )(),
+                    }
+                    if hasattr(self._transport, "_credentials")
+                    else {
+                        "serviceName": "google.ai.generativelanguage.v1beta3.PermissionService",
+                        "credentialsType": None,
+                    },
+                )
+
+    def create_permission(
+        self,
+        request: Optional[
+            Union[permission_service.CreatePermissionRequest, dict]
+        ] = None,
+        *,
+        parent: Optional[str] = None,
+        permission: Optional[gag_permission.Permission] = None,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
+    ) -> gag_permission.Permission:
+        r"""Create a permission to a specific resource.
+
+        .. code-block:: python
+
+            # This snippet has been automatically generated and should be regarded as a
+            # code template only.
+            # It will require modifications to work:
+            # - It may require correct/in-range values for request initialization.
+            # - It may require specifying regional endpoints when creating the service
+            #   client as shown in:
+            #   https://googleapis.dev/python/google-api-core/latest/client_options.html
+            from google.ai import generativelanguage_v1beta3
+
+            def sample_create_permission():
+                # Create a client
+                client = generativelanguage_v1beta3.PermissionServiceClient()
+
+                # Initialize request argument(s)
+                request = generativelanguage_v1beta3.CreatePermissionRequest(
+                    parent="parent_value",
+                )
+
+                # Make the request
+                response = client.create_permission(request=request)
+
+                # Handle the response
+                print(response)
+
+        Args:
+            request (Union[google.ai.generativelanguage_v1beta3.types.CreatePermissionRequest, dict]):
+                The request object. Request to create a ``Permission``.
+            parent (str):
+                Required. The parent resource of the ``Permission``.
+                Format: tunedModels/{tuned_model}
+
+                This corresponds to the ``parent`` field
+                on the ``request`` instance; if ``request`` is provided, this
+                should not be set.
+            permission (google.ai.generativelanguage_v1beta3.types.Permission):
+                Required. The permission to create.
+                This corresponds to the ``permission`` field
+                on the ``request`` instance; if ``request`` is provided, this
+                should not be set.
+            retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                sent along with the request as metadata. Normally, each value must be of type `str`,
+                but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                be of type `bytes`.
+
+        Returns:
+            google.ai.generativelanguage_v1beta3.types.Permission:
+                Permission resource grants user,
+                group or the rest of the world access to
+                the PaLM API resource (e.g. a tuned
+                model, file).
+
+                A role is a collection of permitted
+                operations that allows users to perform
+                specific actions on PaLM API resources.
+                To make them available to users, groups,
+                or service accounts, you assign roles.
+                When you assign a role, you grant
+                permissions that the role contains.
+
+                There are three concentric roles. Each
+                role is a superset of the previous
+                role's permitted operations:
+
+                - reader can use the resource (e.g.
+                  tuned model) for inference
+                - writer has reader's permissions and
+                  additionally can edit and share
+                - owner has writer's permissions and
+                  additionally can delete
+
+        """
+        # Create or coerce a protobuf request object.
+        # - Quick check: If we got a request object, we should *not* have
+        #   gotten any keyword arguments that map to the request.
+        has_flattened_params = any([parent, permission])
+        if request is not None and has_flattened_params:
+            raise ValueError(
+                "If the `request` argument is set, then none of "
+                "the individual field arguments should be set."
+            )
+
+        # - Use the request object if provided (there's no risk of modifying the input as
+        #   there are no flattened fields), or create one.
+        if not isinstance(request, permission_service.CreatePermissionRequest):
+            request = permission_service.CreatePermissionRequest(request)
+            # If we have keyword arguments corresponding to fields on the
+            # request, apply these.
+            if parent is not None:
+                request.parent = parent
+            if permission is not None:
+                request.permission = permission
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = self._transport._wrapped_methods[self._transport.create_permission]
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)),
+        )
+
+        # Validate the universe domain.
+        self._validate_universe_domain()
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def get_permission(
+        self,
+        request: Optional[Union[permission_service.GetPermissionRequest, dict]] = None,
+        *,
+        name: Optional[str] = None,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
+    ) -> permission.Permission:
+        r"""Gets information about a specific Permission.
+
+        .. code-block:: python
+
+            # This snippet has been automatically generated and should be regarded as a
+            # code template only.
+            # It will require modifications to work:
+            # - It may require correct/in-range values for request initialization.
+            # - It may require specifying regional endpoints when creating the service
+            #   client as shown in:
+            #   https://googleapis.dev/python/google-api-core/latest/client_options.html
+            from google.ai import generativelanguage_v1beta3
+
+            def sample_get_permission():
+                # Create a client
+                client = generativelanguage_v1beta3.PermissionServiceClient()
+
+                # Initialize request argument(s)
+                request = generativelanguage_v1beta3.GetPermissionRequest(
+                    name="name_value",
+                )
+
+                # Make the request
+                response = client.get_permission(request=request)
+
+                # Handle the response
+                print(response)
+
+        Args:
+            request (Union[google.ai.generativelanguage_v1beta3.types.GetPermissionRequest, dict]):
+                The request object. Request for getting information about a specific
+                ``Permission``.
+            name (str):
+                Required. The resource name of the permission.
+
+                Format:
+                ``tunedModels/{tuned_model}permissions/{permission}``
+
+                This corresponds to the ``name`` field
+                on the ``request`` instance; if ``request`` is provided, this
+                should not be set.
+            retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                sent along with the request as metadata. Normally, each value must be of type `str`,
+                but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                be of type `bytes`.
+
+        Returns:
+            google.ai.generativelanguage_v1beta3.types.Permission:
+                Permission resource grants user,
+                group or the rest of the world access to
+                the PaLM API resource (e.g. a tuned
+                model, file).
+
+                A role is a collection of permitted
+                operations that allows users to perform
+                specific actions on PaLM API resources.
+                To make them available to users, groups,
+                or service accounts, you assign roles.
+                When you assign a role, you grant
+                permissions that the role contains.
+
+                There are three concentric roles. Each
+                role is a superset of the previous
+                role's permitted operations:
+
+                - reader can use the resource (e.g.
+                  tuned model) for inference
+                - writer has reader's permissions and
+                  additionally can edit and share
+                - owner has writer's permissions and
+                  additionally can delete
+
+        """
+        # Create or coerce a protobuf request object.
+        # - Quick check: If we got a request object, we should *not* have
+        #   gotten any keyword arguments that map to the request.
+        has_flattened_params = any([name])
+        if request is not None and has_flattened_params:
+            raise ValueError(
+                "If the `request` argument is set, then none of "
+                "the individual field arguments should be set."
+            )
+
+        # - Use the request object if provided (there's no risk of modifying the input as
+        #   there are no flattened fields), or create one.
+        if not isinstance(request, permission_service.GetPermissionRequest):
+            request = permission_service.GetPermissionRequest(request)
+            # If we have keyword arguments corresponding to fields on the
+            # request, apply these.
+            if name is not None:
+                request.name = name
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = self._transport._wrapped_methods[self._transport.get_permission]
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Validate the universe domain.
+        self._validate_universe_domain()
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def list_permissions(
+        self,
+        request: Optional[
+            Union[permission_service.ListPermissionsRequest, dict]
+        ] = None,
+        *,
+        parent: Optional[str] = None,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
+    ) -> pagers.ListPermissionsPager:
+        r"""Lists permissions for the specific resource.
+
+        .. code-block:: python
+
+            # This snippet has been automatically generated and should be regarded as a
+            # code template only.
+            # It will require modifications to work:
+            # - It may require correct/in-range values for request initialization.
+            # - It may require specifying regional endpoints when creating the service
+            #   client as shown in:
+            #   https://googleapis.dev/python/google-api-core/latest/client_options.html
+            from google.ai import generativelanguage_v1beta3
+
+            def sample_list_permissions():
+                # Create a client
+                client = generativelanguage_v1beta3.PermissionServiceClient()
+
+                # Initialize request argument(s)
+                request = generativelanguage_v1beta3.ListPermissionsRequest(
+                    parent="parent_value",
+                )
+
+                # Make the request
+                page_result = client.list_permissions(request=request)
+
+                # Handle the response
+                for response in page_result:
+                    print(response)
+
+        Args:
+            request (Union[google.ai.generativelanguage_v1beta3.types.ListPermissionsRequest, dict]):
+                The request object. Request for listing permissions.
+            parent (str):
+                Required. The parent resource of the permissions.
+                Format: tunedModels/{tuned_model}
+
+                This corresponds to the ``parent`` field
+                on the ``request`` instance; if ``request`` is provided, this
+                should not be set.
+            retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                sent along with the request as metadata. Normally, each value must be of type `str`,
+                but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                be of type `bytes`.
+
+        Returns:
+            google.ai.generativelanguage_v1beta3.services.permission_service.pagers.ListPermissionsPager:
+                Response from ListPermissions containing a paginated list of
+                   permissions.
+
+                Iterating over this object will yield results and
+                resolve additional pages automatically.
+
+        """
+        # Create or coerce a protobuf request object.
+        # - Quick check: If we got a request object, we should *not* have
+        #   gotten any keyword arguments that map to the request.
+        has_flattened_params = any([parent])
+        if request is not None and has_flattened_params:
+            raise ValueError(
+                "If the `request` argument is set, then none of "
+                "the individual field arguments should be set."
+            )
+
+        # - Use the request object if provided (there's no risk of modifying the input as
+        #   there are no flattened fields), or create one.
+        if not isinstance(request, permission_service.ListPermissionsRequest):
+            request = permission_service.ListPermissionsRequest(request)
+            # If we have keyword arguments corresponding to fields on the
+            # request, apply these.
+            if parent is not None:
+                request.parent = parent
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = self._transport._wrapped_methods[self._transport.list_permissions]
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("parent", request.parent),)),
+        )
+
+        # Validate the universe domain.
+        self._validate_universe_domain()
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # This method is paged; wrap the response in a pager, which provides
+        # an `__iter__` convenience method.
+        response = pagers.ListPermissionsPager(
+            method=rpc,
+            request=request,
+            response=response,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def update_permission(
+        self,
+        request: Optional[
+            Union[permission_service.UpdatePermissionRequest, dict]
+        ] = None,
+        *,
+        permission: Optional[gag_permission.Permission] = None,
+        update_mask: Optional[field_mask_pb2.FieldMask] = None,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
+    ) -> gag_permission.Permission:
+        r"""Updates the permission.
+
+        .. code-block:: python
+
+            # This snippet has been automatically generated and should be regarded as a
+            # code template only.
+            # It will require modifications to work:
+            # - It may require correct/in-range values for request initialization.
+            # - It may require specifying regional endpoints when creating the service
+            #   client as shown in:
+            #   https://googleapis.dev/python/google-api-core/latest/client_options.html
+            from google.ai import generativelanguage_v1beta3
+
+            def sample_update_permission():
+                # Create a client
+                client = generativelanguage_v1beta3.PermissionServiceClient()
+
+                # Initialize request argument(s)
+                request = generativelanguage_v1beta3.UpdatePermissionRequest(
+                )
+
+                # Make the request
+                response = client.update_permission(request=request)
+
+                # Handle the response
+                print(response)
+
+        Args:
+            request (Union[google.ai.generativelanguage_v1beta3.types.UpdatePermissionRequest, dict]):
+                The request object. Request to update the ``Permission``.
+            permission (google.ai.generativelanguage_v1beta3.types.Permission):
+                Required. The permission to update.
+
+                The permission's ``name`` field is used to identify the
+                permission to update.
+
+                This corresponds to the ``permission`` field
+                on the ``request`` instance; if ``request`` is provided, this
+                should not be set.
+            update_mask (google.protobuf.field_mask_pb2.FieldMask):
+                Required. The list of fields to update. Accepted ones:
+
+                -  role (``Permission.role`` field)
+
+                This corresponds to the ``update_mask`` field
+                on the ``request`` instance; if ``request`` is provided, this
+                should not be set.
+            retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                sent along with the request as metadata. Normally, each value must be of type `str`,
+                but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                be of type `bytes`.
+
+        Returns:
+            google.ai.generativelanguage_v1beta3.types.Permission:
+                Permission resource grants user,
+                group or the rest of the world access to
+                the PaLM API resource (e.g. a tuned
+                model, file).
+
+                A role is a collection of permitted
+                operations that allows users to perform
+                specific actions on PaLM API resources.
+                To make them available to users, groups,
+                or service accounts, you assign roles.
+                When you assign a role, you grant
+                permissions that the role contains.
+
+                There are three concentric roles. Each
+                role is a superset of the previous
+                role's permitted operations:
+
+                - reader can use the resource (e.g.
+                  tuned model) for inference
+                - writer has reader's permissions and
+                  additionally can edit and share
+                - owner has writer's permissions and
+                  additionally can delete
+
+        """
+        # Create or coerce a protobuf request object.
+        # - Quick check: If we got a request object, we should *not* have
+        #   gotten any keyword arguments that map to the request.
+        has_flattened_params = any([permission, update_mask])
+        if request is not None and has_flattened_params:
+            raise ValueError(
+                "If the `request` argument is set, then none of "
+                "the individual field arguments should be set."
+            )
+
+        # - Use the request object if provided (there's no risk of modifying the input as
+        #   there are no flattened fields), or create one.
+        if not isinstance(request, permission_service.UpdatePermissionRequest):
+            request = permission_service.UpdatePermissionRequest(request)
+            # If we have keyword arguments corresponding to fields on the
+            # request, apply these.
+            if permission is not None:
+                request.permission = permission
+            if update_mask is not None:
+                request.update_mask = update_mask
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = self._transport._wrapped_methods[self._transport.update_permission]
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata(
+                (("permission.name", request.permission.name),)
+            ),
+        )
+
+        # Validate the universe domain.
+        self._validate_universe_domain()
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def delete_permission(
+        self,
+        request: Optional[
+            Union[permission_service.DeletePermissionRequest, dict]
+        ] = None,
+        *,
+        name: Optional[str] = None,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
+    ) -> None:
+        r"""Deletes the permission.
+
+        .. code-block:: python
+
+            # This snippet has been automatically generated and should be regarded as a
+            # code template only.
+            # It will require modifications to work:
+            # - It may require correct/in-range values for request initialization.
+            # - It may require specifying regional endpoints when creating the service
+            #   client as shown in:
+            #   https://googleapis.dev/python/google-api-core/latest/client_options.html
+            from google.ai import generativelanguage_v1beta3
+
+            def sample_delete_permission():
+                # Create a client
+                client = generativelanguage_v1beta3.PermissionServiceClient()
+
+                # Initialize request argument(s)
+                request = generativelanguage_v1beta3.DeletePermissionRequest(
+                    name="name_value",
+                )
+
+                # Make the request
+                client.delete_permission(request=request)
+
+        Args:
+            request (Union[google.ai.generativelanguage_v1beta3.types.DeletePermissionRequest, dict]):
+                The request object. Request to delete the ``Permission``.
+            name (str):
+                Required. The resource name of the permission. Format:
+                ``tunedModels/{tuned_model}/permissions/{permission}``
+
+                This corresponds to the ``name`` field
+                on the ``request`` instance; if ``request`` is provided, this
+                should not be set.
+            retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                sent along with the request as metadata. Normally, each value must be of type `str`,
+                but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                be of type `bytes`.
+        """
+        # Create or coerce a protobuf request object.
+        # - Quick check: If we got a request object, we should *not* have
+        #   gotten any keyword arguments that map to the request.
+        has_flattened_params = any([name])
+        if request is not None and has_flattened_params:
+            raise ValueError(
+                "If the `request` argument is set, then none of "
+                "the individual field arguments should be set."
+            )
+
+        # - Use the request object if provided (there's no risk of modifying the input as
+        #   there are no flattened fields), or create one.
+        if not isinstance(request, permission_service.DeletePermissionRequest):
+            request = permission_service.DeletePermissionRequest(request)
+            # If we have keyword arguments corresponding to fields on the
+            # request, apply these.
+            if name is not None:
+                request.name = name
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = self._transport._wrapped_methods[self._transport.delete_permission]
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Validate the universe domain.
+        self._validate_universe_domain()
+
+        # Send the request.
+        rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+    def transfer_ownership(
+        self,
+        request: Optional[
+            Union[permission_service.TransferOwnershipRequest, dict]
+        ] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
+    ) -> permission_service.TransferOwnershipResponse:
+        r"""Transfers ownership of the tuned model.
+        This is the only way to change ownership of the tuned
+        model. The current owner will be downgraded to writer
+        role.
+
+        .. code-block:: python
+
+            # This snippet has been automatically generated and should be regarded as a
+            # code template only.
+            # It will require modifications to work:
+            # - It may require correct/in-range values for request initialization.
+            # - It may require specifying regional endpoints when creating the service
+            #   client as shown in:
+            #   https://googleapis.dev/python/google-api-core/latest/client_options.html
+            from google.ai import generativelanguage_v1beta3
+
+            def sample_transfer_ownership():
+                # Create a client
+                client = generativelanguage_v1beta3.PermissionServiceClient()
+
+                # Initialize request argument(s)
+                request = generativelanguage_v1beta3.TransferOwnershipRequest(
+                    name="name_value",
+                    email_address="email_address_value",
+                )
+
+                # Make the request
+                response = client.transfer_ownership(request=request)
+
+                # Handle the response
+                print(response)
+
+        Args:
+            request (Union[google.ai.generativelanguage_v1beta3.types.TransferOwnershipRequest, dict]):
+                The request object. Request to transfer the ownership of
+                the tuned model.
+            retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                sent along with the request as metadata. Normally, each value must be of type `str`,
+                but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                be of type `bytes`.
+
+        Returns:
+            google.ai.generativelanguage_v1beta3.types.TransferOwnershipResponse:
+                Response from TransferOwnership.
+        """
+        # Create or coerce a protobuf request object.
+        # - Use the request object if provided (there's no risk of modifying the input as
+        #   there are no flattened fields), or create one.
+        if not isinstance(request, permission_service.TransferOwnershipRequest):
+            request = permission_service.TransferOwnershipRequest(request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = self._transport._wrapped_methods[self._transport.transfer_ownership]
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Validate the universe domain.
+        self._validate_universe_domain()
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
+    def __enter__(self) -> "PermissionServiceClient":
+        return self
+
+    def __exit__(self, type, value, traceback):
+        """Releases underlying transport's resources.
+
+        .. warning::
+            ONLY use as a context manager if the transport is NOT shared
+            with other clients! Exiting the with block will CLOSE the transport
+            and may cause errors in other clients!
+        """
+        self.transport.close()
+
+
+DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
+    gapic_version=package_version.__version__
+)
+
+
+__all__ = ("PermissionServiceClient",)

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/services/permission_service/pagers.py

@@ -0,0 +1,197 @@
+# -*- coding: utf-8 -*-
+# 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 (
+    Any,
+    AsyncIterator,
+    Awaitable,
+    Callable,
+    Iterator,
+    Optional,
+    Sequence,
+    Tuple,
+    Union,
+)
+
+from google.api_core import gapic_v1
+from google.api_core import retry as retries
+from google.api_core import retry_async as retries_async
+
+try:
+    OptionalRetry = Union[retries.Retry, gapic_v1.method._MethodDefault, None]
+    OptionalAsyncRetry = Union[
+        retries_async.AsyncRetry, gapic_v1.method._MethodDefault, None
+    ]
+except AttributeError:  # pragma: NO COVER
+    OptionalRetry = Union[retries.Retry, object, None]  # type: ignore
+    OptionalAsyncRetry = Union[retries_async.AsyncRetry, object, None]  # type: ignore
+
+from google.ai.generativelanguage_v1beta3.types import permission, permission_service
+
+
+class ListPermissionsPager:
+    """A pager for iterating through ``list_permissions`` requests.
+
+    This class thinly wraps an initial
+    :class:`google.ai.generativelanguage_v1beta3.types.ListPermissionsResponse` object, and
+    provides an ``__iter__`` method to iterate through its
+    ``permissions`` field.
+
+    If there are more pages, the ``__iter__`` method will make additional
+    ``ListPermissions`` requests and continue to iterate
+    through the ``permissions`` field on the
+    corresponding responses.
+
+    All the usual :class:`google.ai.generativelanguage_v1beta3.types.ListPermissionsResponse`
+    attributes are available on the pager. If multiple requests are made, only
+    the most recent response is retained, and thus used for attribute lookup.
+    """
+
+    def __init__(
+        self,
+        method: Callable[..., permission_service.ListPermissionsResponse],
+        request: permission_service.ListPermissionsRequest,
+        response: permission_service.ListPermissionsResponse,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]] = ()
+    ):
+        """Instantiate the pager.
+
+        Args:
+            method (Callable): The method that was originally called, and
+                which instantiated this pager.
+            request (google.ai.generativelanguage_v1beta3.types.ListPermissionsRequest):
+                The initial request object.
+            response (google.ai.generativelanguage_v1beta3.types.ListPermissionsResponse):
+                The initial response object.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                sent along with the request as metadata. Normally, each value must be of type `str`,
+                but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                be of type `bytes`.
+        """
+        self._method = method
+        self._request = permission_service.ListPermissionsRequest(request)
+        self._response = response
+        self._retry = retry
+        self._timeout = timeout
+        self._metadata = metadata
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._response, name)
+
+    @property
+    def pages(self) -> Iterator[permission_service.ListPermissionsResponse]:
+        yield self._response
+        while self._response.next_page_token:
+            self._request.page_token = self._response.next_page_token
+            self._response = self._method(
+                self._request,
+                retry=self._retry,
+                timeout=self._timeout,
+                metadata=self._metadata,
+            )
+            yield self._response
+
+    def __iter__(self) -> Iterator[permission.Permission]:
+        for page in self.pages:
+            yield from page.permissions
+
+    def __repr__(self) -> str:
+        return "{0}<{1!r}>".format(self.__class__.__name__, self._response)
+
+
+class ListPermissionsAsyncPager:
+    """A pager for iterating through ``list_permissions`` requests.
+
+    This class thinly wraps an initial
+    :class:`google.ai.generativelanguage_v1beta3.types.ListPermissionsResponse` object, and
+    provides an ``__aiter__`` method to iterate through its
+    ``permissions`` field.
+
+    If there are more pages, the ``__aiter__`` method will make additional
+    ``ListPermissions`` requests and continue to iterate
+    through the ``permissions`` field on the
+    corresponding responses.
+
+    All the usual :class:`google.ai.generativelanguage_v1beta3.types.ListPermissionsResponse`
+    attributes are available on the pager. If multiple requests are made, only
+    the most recent response is retained, and thus used for attribute lookup.
+    """
+
+    def __init__(
+        self,
+        method: Callable[..., Awaitable[permission_service.ListPermissionsResponse]],
+        request: permission_service.ListPermissionsRequest,
+        response: permission_service.ListPermissionsResponse,
+        *,
+        retry: OptionalAsyncRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]] = ()
+    ):
+        """Instantiates the pager.
+
+        Args:
+            method (Callable): The method that was originally called, and
+                which instantiated this pager.
+            request (google.ai.generativelanguage_v1beta3.types.ListPermissionsRequest):
+                The initial request object.
+            response (google.ai.generativelanguage_v1beta3.types.ListPermissionsResponse):
+                The initial response object.
+            retry (google.api_core.retry.AsyncRetry): Designation of what errors,
+                if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                sent along with the request as metadata. Normally, each value must be of type `str`,
+                but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                be of type `bytes`.
+        """
+        self._method = method
+        self._request = permission_service.ListPermissionsRequest(request)
+        self._response = response
+        self._retry = retry
+        self._timeout = timeout
+        self._metadata = metadata
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._response, name)
+
+    @property
+    async def pages(self) -> AsyncIterator[permission_service.ListPermissionsResponse]:
+        yield self._response
+        while self._response.next_page_token:
+            self._request.page_token = self._response.next_page_token
+            self._response = await self._method(
+                self._request,
+                retry=self._retry,
+                timeout=self._timeout,
+                metadata=self._metadata,
+            )
+            yield self._response
+
+    def __aiter__(self) -> AsyncIterator[permission.Permission]:
+        async def async_generator():
+            async for page in self.pages:
+                for response in page.permissions:
+                    yield response
+
+        return async_generator()
+
+    def __repr__(self) -> str:
+        return "{0}<{1!r}>".format(self.__class__.__name__, self._response)

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/services/permission_service/transports/__init__.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+# 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 collections import OrderedDict
+from typing import Dict, Type
+
+from .base import PermissionServiceTransport
+from .grpc import PermissionServiceGrpcTransport
+from .grpc_asyncio import PermissionServiceGrpcAsyncIOTransport
+from .rest import PermissionServiceRestInterceptor, PermissionServiceRestTransport
+
+# Compile a registry of transports.
+_transport_registry = OrderedDict()  # type: Dict[str, Type[PermissionServiceTransport]]
+_transport_registry["grpc"] = PermissionServiceGrpcTransport
+_transport_registry["grpc_asyncio"] = PermissionServiceGrpcAsyncIOTransport
+_transport_registry["rest"] = PermissionServiceRestTransport
+
+__all__ = (
+    "PermissionServiceTransport",
+    "PermissionServiceGrpcTransport",
+    "PermissionServiceGrpcAsyncIOTransport",
+    "PermissionServiceRestTransport",
+    "PermissionServiceRestInterceptor",
+)

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/services/permission_service/transports/base.py

@@ -0,0 +1,241 @@
+# -*- coding: utf-8 -*-
+# 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 abc
+from typing import Awaitable, Callable, Dict, Optional, Sequence, Union
+
+import google.api_core
+from google.api_core import exceptions as core_exceptions
+from google.api_core import gapic_v1
+from google.api_core import retry as retries
+import google.auth  # type: ignore
+from google.auth import credentials as ga_credentials  # type: ignore
+from google.longrunning import operations_pb2  # type: ignore
+from google.oauth2 import service_account  # type: ignore
+from google.protobuf import empty_pb2  # type: ignore
+
+from google.ai.generativelanguage_v1beta3 import gapic_version as package_version
+from google.ai.generativelanguage_v1beta3.types import permission as gag_permission
+from google.ai.generativelanguage_v1beta3.types import permission
+from google.ai.generativelanguage_v1beta3.types import permission_service
+
+DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
+    gapic_version=package_version.__version__
+)
+
+
+class PermissionServiceTransport(abc.ABC):
+    """Abstract transport class for PermissionService."""
+
+    AUTH_SCOPES = ()
+
+    DEFAULT_HOST: str = "generativelanguage.googleapis.com"
+
+    def __init__(
+        self,
+        *,
+        host: str = DEFAULT_HOST,
+        credentials: Optional[ga_credentials.Credentials] = None,
+        credentials_file: Optional[str] = None,
+        scopes: Optional[Sequence[str]] = None,
+        quota_project_id: Optional[str] = None,
+        client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
+        always_use_jwt_access: Optional[bool] = False,
+        api_audience: Optional[str] = None,
+        **kwargs,
+    ) -> None:
+        """Instantiate the transport.
+
+        Args:
+            host (Optional[str]):
+                 The hostname to connect to (default: 'generativelanguage.googleapis.com').
+            credentials (Optional[google.auth.credentials.Credentials]): The
+                authorization credentials to attach to requests. These
+                credentials identify the application to the service; if none
+                are specified, the client will attempt to ascertain the
+                credentials from the environment.
+            credentials_file (Optional[str]): A file with credentials that can
+                be loaded with :func:`google.auth.load_credentials_from_file`.
+                This argument is mutually exclusive with credentials.
+            scopes (Optional[Sequence[str]]): A list of scopes.
+            quota_project_id (Optional[str]): An optional project to use for billing
+                and quota.
+            client_info (google.api_core.gapic_v1.client_info.ClientInfo):
+                The client info used to send a user-agent string along with
+                API requests. If ``None``, then default info will be used.
+                Generally, you only need to set this if you're developing
+                your own client library.
+            always_use_jwt_access (Optional[bool]): Whether self signed JWT should
+                be used for service account credentials.
+        """
+
+        scopes_kwargs = {"scopes": scopes, "default_scopes": self.AUTH_SCOPES}
+
+        # Save the scopes.
+        self._scopes = scopes
+        if not hasattr(self, "_ignore_credentials"):
+            self._ignore_credentials: bool = False
+
+        # If no credentials are provided, then determine the appropriate
+        # defaults.
+        if credentials and credentials_file:
+            raise core_exceptions.DuplicateCredentialArgs(
+                "'credentials_file' and 'credentials' are mutually exclusive"
+            )
+
+        if credentials_file is not None:
+            credentials, _ = google.auth.load_credentials_from_file(
+                credentials_file, **scopes_kwargs, quota_project_id=quota_project_id
+            )
+        elif credentials is None and not self._ignore_credentials:
+            credentials, _ = google.auth.default(
+                **scopes_kwargs, quota_project_id=quota_project_id
+            )
+            # Don't apply audience if the credentials file passed from user.
+            if hasattr(credentials, "with_gdch_audience"):
+                credentials = credentials.with_gdch_audience(
+                    api_audience if api_audience else host
+                )
+
+        # If the credentials are service account credentials, then always try to use self signed JWT.
+        if (
+            always_use_jwt_access
+            and isinstance(credentials, service_account.Credentials)
+            and hasattr(service_account.Credentials, "with_always_use_jwt_access")
+        ):
+            credentials = credentials.with_always_use_jwt_access(True)
+
+        # Save the credentials.
+        self._credentials = credentials
+
+        # Save the hostname. Default to port 443 (HTTPS) if none is specified.
+        if ":" not in host:
+            host += ":443"
+        self._host = host
+
+    @property
+    def host(self):
+        return self._host
+
+    def _prep_wrapped_messages(self, client_info):
+        # Precompute the wrapped methods.
+        self._wrapped_methods = {
+            self.create_permission: gapic_v1.method.wrap_method(
+                self.create_permission,
+                default_timeout=None,
+                client_info=client_info,
+            ),
+            self.get_permission: gapic_v1.method.wrap_method(
+                self.get_permission,
+                default_timeout=None,
+                client_info=client_info,
+            ),
+            self.list_permissions: gapic_v1.method.wrap_method(
+                self.list_permissions,
+                default_timeout=None,
+                client_info=client_info,
+            ),
+            self.update_permission: gapic_v1.method.wrap_method(
+                self.update_permission,
+                default_timeout=None,
+                client_info=client_info,
+            ),
+            self.delete_permission: gapic_v1.method.wrap_method(
+                self.delete_permission,
+                default_timeout=None,
+                client_info=client_info,
+            ),
+            self.transfer_ownership: gapic_v1.method.wrap_method(
+                self.transfer_ownership,
+                default_timeout=None,
+                client_info=client_info,
+            ),
+        }
+
+    def close(self):
+        """Closes resources associated with the transport.
+
+        .. warning::
+             Only call this method if the transport is NOT shared
+             with other clients - this may cause errors in other clients!
+        """
+        raise NotImplementedError()
+
+    @property
+    def create_permission(
+        self,
+    ) -> Callable[
+        [permission_service.CreatePermissionRequest],
+        Union[gag_permission.Permission, Awaitable[gag_permission.Permission]],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def get_permission(
+        self,
+    ) -> Callable[
+        [permission_service.GetPermissionRequest],
+        Union[permission.Permission, Awaitable[permission.Permission]],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def list_permissions(
+        self,
+    ) -> Callable[
+        [permission_service.ListPermissionsRequest],
+        Union[
+            permission_service.ListPermissionsResponse,
+            Awaitable[permission_service.ListPermissionsResponse],
+        ],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def update_permission(
+        self,
+    ) -> Callable[
+        [permission_service.UpdatePermissionRequest],
+        Union[gag_permission.Permission, Awaitable[gag_permission.Permission]],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def delete_permission(
+        self,
+    ) -> Callable[
+        [permission_service.DeletePermissionRequest],
+        Union[empty_pb2.Empty, Awaitable[empty_pb2.Empty]],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def transfer_ownership(
+        self,
+    ) -> Callable[
+        [permission_service.TransferOwnershipRequest],
+        Union[
+            permission_service.TransferOwnershipResponse,
+            Awaitable[permission_service.TransferOwnershipResponse],
+        ],
+    ]:
+        raise NotImplementedError()
+
+    @property
+    def kind(self) -> str:
+        raise NotImplementedError()
+
+
+__all__ = ("PermissionServiceTransport",)

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/services/permission_service/transports/grpc.py

@@ -0,0 +1,505 @@
+# -*- coding: utf-8 -*-
+# 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 json
+import logging as std_logging
+import pickle
+from typing import Callable, Dict, Optional, Sequence, Tuple, Union
+import warnings
+
+from google.api_core import gapic_v1, grpc_helpers
+import google.auth  # type: ignore
+from google.auth import credentials as ga_credentials  # type: ignore
+from google.auth.transport.grpc import SslCredentials  # type: ignore
+from google.longrunning import operations_pb2  # type: ignore
+from google.protobuf import empty_pb2  # type: ignore
+from google.protobuf.json_format import MessageToJson
+import google.protobuf.message
+import grpc  # type: ignore
+import proto  # type: ignore
+
+from google.ai.generativelanguage_v1beta3.types import permission as gag_permission
+from google.ai.generativelanguage_v1beta3.types import permission
+from google.ai.generativelanguage_v1beta3.types import permission_service
+
+from .base import DEFAULT_CLIENT_INFO, PermissionServiceTransport
+
+try:
+    from google.api_core import client_logging  # type: ignore
+
+    CLIENT_LOGGING_SUPPORTED = True  # pragma: NO COVER
+except ImportError:  # pragma: NO COVER
+    CLIENT_LOGGING_SUPPORTED = False
+
+_LOGGER = std_logging.getLogger(__name__)
+
+
+class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor):  # pragma: NO COVER
+    def intercept_unary_unary(self, continuation, client_call_details, request):
+        logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+            std_logging.DEBUG
+        )
+        if logging_enabled:  # pragma: NO COVER
+            request_metadata = client_call_details.metadata
+            if isinstance(request, proto.Message):
+                request_payload = type(request).to_json(request)
+            elif isinstance(request, google.protobuf.message.Message):
+                request_payload = MessageToJson(request)
+            else:
+                request_payload = f"{type(request).__name__}: {pickle.dumps(request)}"
+
+            request_metadata = {
+                key: value.decode("utf-8") if isinstance(value, bytes) else value
+                for key, value in request_metadata
+            }
+            grpc_request = {
+                "payload": request_payload,
+                "requestMethod": "grpc",
+                "metadata": dict(request_metadata),
+            }
+            _LOGGER.debug(
+                f"Sending request for {client_call_details.method}",
+                extra={
+                    "serviceName": "google.ai.generativelanguage.v1beta3.PermissionService",
+                    "rpcName": client_call_details.method,
+                    "request": grpc_request,
+                    "metadata": grpc_request["metadata"],
+                },
+            )
+
+        response = continuation(client_call_details, request)
+        if logging_enabled:  # pragma: NO COVER
+            response_metadata = response.trailing_metadata()
+            # Convert gRPC metadata `<class 'grpc.aio._metadata.Metadata'>` to list of tuples
+            metadata = (
+                dict([(k, str(v)) for k, v in response_metadata])
+                if response_metadata
+                else None
+            )
+            result = response.result()
+            if isinstance(result, proto.Message):
+                response_payload = type(result).to_json(result)
+            elif isinstance(result, google.protobuf.message.Message):
+                response_payload = MessageToJson(result)
+            else:
+                response_payload = f"{type(result).__name__}: {pickle.dumps(result)}"
+            grpc_response = {
+                "payload": response_payload,
+                "metadata": metadata,
+                "status": "OK",
+            }
+            _LOGGER.debug(
+                f"Received response for {client_call_details.method}.",
+                extra={
+                    "serviceName": "google.ai.generativelanguage.v1beta3.PermissionService",
+                    "rpcName": client_call_details.method,
+                    "response": grpc_response,
+                    "metadata": grpc_response["metadata"],
+                },
+            )
+        return response
+
+
+class PermissionServiceGrpcTransport(PermissionServiceTransport):
+    """gRPC backend transport for PermissionService.
+
+    Provides methods for managing permissions to PaLM API
+    resources.
+
+    This class defines the same methods as the primary client, so the
+    primary client can load the underlying transport implementation
+    and call it.
+
+    It sends protocol buffers over the wire using gRPC (which is built on
+    top of HTTP/2); the ``grpcio`` package must be installed.
+    """
+
+    _stubs: Dict[str, Callable]
+
+    def __init__(
+        self,
+        *,
+        host: str = "generativelanguage.googleapis.com",
+        credentials: Optional[ga_credentials.Credentials] = None,
+        credentials_file: Optional[str] = None,
+        scopes: Optional[Sequence[str]] = None,
+        channel: Optional[Union[grpc.Channel, Callable[..., grpc.Channel]]] = None,
+        api_mtls_endpoint: Optional[str] = None,
+        client_cert_source: Optional[Callable[[], Tuple[bytes, bytes]]] = None,
+        ssl_channel_credentials: Optional[grpc.ChannelCredentials] = None,
+        client_cert_source_for_mtls: Optional[Callable[[], Tuple[bytes, bytes]]] = None,
+        quota_project_id: Optional[str] = None,
+        client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
+        always_use_jwt_access: Optional[bool] = False,
+        api_audience: Optional[str] = None,
+    ) -> None:
+        """Instantiate the transport.
+
+        Args:
+            host (Optional[str]):
+                 The hostname to connect to (default: 'generativelanguage.googleapis.com').
+            credentials (Optional[google.auth.credentials.Credentials]): The
+                authorization credentials to attach to requests. These
+                credentials identify the application to the service; if none
+                are specified, the client will attempt to ascertain the
+                credentials from the environment.
+                This argument is ignored if a ``channel`` instance is provided.
+            credentials_file (Optional[str]): A file with credentials that can
+                be loaded with :func:`google.auth.load_credentials_from_file`.
+                This argument is ignored if a ``channel`` instance is provided.
+            scopes (Optional(Sequence[str])): A list of scopes. This argument is
+                ignored if a ``channel`` instance is provided.
+            channel (Optional[Union[grpc.Channel, Callable[..., grpc.Channel]]]):
+                A ``Channel`` instance through which to make calls, or a Callable
+                that constructs and returns one. If set to None, ``self.create_channel``
+                is used to create the channel. If a Callable is given, it will be called
+                with the same arguments as used in ``self.create_channel``.
+            api_mtls_endpoint (Optional[str]): Deprecated. The mutual TLS endpoint.
+                If provided, it overrides the ``host`` argument and tries to create
+                a mutual TLS channel with client SSL credentials from
+                ``client_cert_source`` or application default SSL credentials.
+            client_cert_source (Optional[Callable[[], Tuple[bytes, bytes]]]):
+                Deprecated. A callback to provide client SSL certificate bytes and
+                private key bytes, both in PEM format. It is ignored if
+                ``api_mtls_endpoint`` is None.
+            ssl_channel_credentials (grpc.ChannelCredentials): SSL credentials
+                for the grpc channel. It is ignored if a ``channel`` instance is provided.
+            client_cert_source_for_mtls (Optional[Callable[[], Tuple[bytes, bytes]]]):
+                A callback to provide client certificate bytes and private key bytes,
+                both in PEM format. It is used to configure a mutual TLS channel. It is
+                ignored if a ``channel`` instance or ``ssl_channel_credentials`` is provided.
+            quota_project_id (Optional[str]): An optional project to use for billing
+                and quota.
+            client_info (google.api_core.gapic_v1.client_info.ClientInfo):
+                The client info used to send a user-agent string along with
+                API requests. If ``None``, then default info will be used.
+                Generally, you only need to set this if you're developing
+                your own client library.
+            always_use_jwt_access (Optional[bool]): Whether self signed JWT should
+                be used for service account credentials.
+
+        Raises:
+          google.auth.exceptions.MutualTLSChannelError: If mutual TLS transport
+              creation failed for any reason.
+          google.api_core.exceptions.DuplicateCredentialArgs: If both ``credentials``
+              and ``credentials_file`` are passed.
+        """
+        self._grpc_channel = None
+        self._ssl_channel_credentials = ssl_channel_credentials
+        self._stubs: Dict[str, Callable] = {}
+
+        if api_mtls_endpoint:
+            warnings.warn("api_mtls_endpoint is deprecated", DeprecationWarning)
+        if client_cert_source:
+            warnings.warn("client_cert_source is deprecated", DeprecationWarning)
+
+        if isinstance(channel, grpc.Channel):
+            # Ignore credentials if a channel was passed.
+            credentials = None
+            self._ignore_credentials = True
+            # If a channel was explicitly provided, set it.
+            self._grpc_channel = channel
+            self._ssl_channel_credentials = None
+
+        else:
+            if api_mtls_endpoint:
+                host = api_mtls_endpoint
+
+                # Create SSL credentials with client_cert_source or application
+                # default SSL credentials.
+                if client_cert_source:
+                    cert, key = client_cert_source()
+                    self._ssl_channel_credentials = grpc.ssl_channel_credentials(
+                        certificate_chain=cert, private_key=key
+                    )
+                else:
+                    self._ssl_channel_credentials = SslCredentials().ssl_credentials
+
+            else:
+                if client_cert_source_for_mtls and not ssl_channel_credentials:
+                    cert, key = client_cert_source_for_mtls()
+                    self._ssl_channel_credentials = grpc.ssl_channel_credentials(
+                        certificate_chain=cert, private_key=key
+                    )
+
+        # The base transport sets the host, credentials and scopes
+        super().__init__(
+            host=host,
+            credentials=credentials,
+            credentials_file=credentials_file,
+            scopes=scopes,
+            quota_project_id=quota_project_id,
+            client_info=client_info,
+            always_use_jwt_access=always_use_jwt_access,
+            api_audience=api_audience,
+        )
+
+        if not self._grpc_channel:
+            # initialize with the provided callable or the default channel
+            channel_init = channel or type(self).create_channel
+            self._grpc_channel = channel_init(
+                self._host,
+                # use the credentials which are saved
+                credentials=self._credentials,
+                # Set ``credentials_file`` to ``None`` here as
+                # the credentials that we saved earlier should be used.
+                credentials_file=None,
+                scopes=self._scopes,
+                ssl_credentials=self._ssl_channel_credentials,
+                quota_project_id=quota_project_id,
+                options=[
+                    ("grpc.max_send_message_length", -1),
+                    ("grpc.max_receive_message_length", -1),
+                ],
+            )
+
+        self._interceptor = _LoggingClientInterceptor()
+        self._logged_channel = grpc.intercept_channel(
+            self._grpc_channel, self._interceptor
+        )
+
+        # Wrap messages. This must be done after self._logged_channel exists
+        self._prep_wrapped_messages(client_info)
+
+    @classmethod
+    def create_channel(
+        cls,
+        host: str = "generativelanguage.googleapis.com",
+        credentials: Optional[ga_credentials.Credentials] = None,
+        credentials_file: Optional[str] = None,
+        scopes: Optional[Sequence[str]] = None,
+        quota_project_id: Optional[str] = None,
+        **kwargs,
+    ) -> grpc.Channel:
+        """Create and return a gRPC channel object.
+        Args:
+            host (Optional[str]): The host for the channel to use.
+            credentials (Optional[~.Credentials]): The
+                authorization credentials to attach to requests. These
+                credentials identify this application to the service. If
+                none are specified, the client will attempt to ascertain
+                the credentials from the environment.
+            credentials_file (Optional[str]): A file with credentials that can
+                be loaded with :func:`google.auth.load_credentials_from_file`.
+                This argument is mutually exclusive with credentials.
+            scopes (Optional[Sequence[str]]): A optional list of scopes needed for this
+                service. These are only used when credentials are not specified and
+                are passed to :func:`google.auth.default`.
+            quota_project_id (Optional[str]): An optional project to use for billing
+                and quota.
+            kwargs (Optional[dict]): Keyword arguments, which are passed to the
+                channel creation.
+        Returns:
+            grpc.Channel: A gRPC channel object.
+
+        Raises:
+            google.api_core.exceptions.DuplicateCredentialArgs: If both ``credentials``
+              and ``credentials_file`` are passed.
+        """
+
+        return grpc_helpers.create_channel(
+            host,
+            credentials=credentials,
+            credentials_file=credentials_file,
+            quota_project_id=quota_project_id,
+            default_scopes=cls.AUTH_SCOPES,
+            scopes=scopes,
+            default_host=cls.DEFAULT_HOST,
+            **kwargs,
+        )
+
+    @property
+    def grpc_channel(self) -> grpc.Channel:
+        """Return the channel designed to connect to this service."""
+        return self._grpc_channel
+
+    @property
+    def create_permission(
+        self,
+    ) -> Callable[
+        [permission_service.CreatePermissionRequest], gag_permission.Permission
+    ]:
+        r"""Return a callable for the create permission method over gRPC.
+
+        Create a permission to a specific resource.
+
+        Returns:
+            Callable[[~.CreatePermissionRequest],
+                    ~.Permission]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "create_permission" not in self._stubs:
+            self._stubs["create_permission"] = self._logged_channel.unary_unary(
+                "/google.ai.generativelanguage.v1beta3.PermissionService/CreatePermission",
+                request_serializer=permission_service.CreatePermissionRequest.serialize,
+                response_deserializer=gag_permission.Permission.deserialize,
+            )
+        return self._stubs["create_permission"]
+
+    @property
+    def get_permission(
+        self,
+    ) -> Callable[[permission_service.GetPermissionRequest], permission.Permission]:
+        r"""Return a callable for the get permission method over gRPC.
+
+        Gets information about a specific Permission.
+
+        Returns:
+            Callable[[~.GetPermissionRequest],
+                    ~.Permission]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "get_permission" not in self._stubs:
+            self._stubs["get_permission"] = self._logged_channel.unary_unary(
+                "/google.ai.generativelanguage.v1beta3.PermissionService/GetPermission",
+                request_serializer=permission_service.GetPermissionRequest.serialize,
+                response_deserializer=permission.Permission.deserialize,
+            )
+        return self._stubs["get_permission"]
+
+    @property
+    def list_permissions(
+        self,
+    ) -> Callable[
+        [permission_service.ListPermissionsRequest],
+        permission_service.ListPermissionsResponse,
+    ]:
+        r"""Return a callable for the list permissions method over gRPC.
+
+        Lists permissions for the specific resource.
+
+        Returns:
+            Callable[[~.ListPermissionsRequest],
+                    ~.ListPermissionsResponse]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "list_permissions" not in self._stubs:
+            self._stubs["list_permissions"] = self._logged_channel.unary_unary(
+                "/google.ai.generativelanguage.v1beta3.PermissionService/ListPermissions",
+                request_serializer=permission_service.ListPermissionsRequest.serialize,
+                response_deserializer=permission_service.ListPermissionsResponse.deserialize,
+            )
+        return self._stubs["list_permissions"]
+
+    @property
+    def update_permission(
+        self,
+    ) -> Callable[
+        [permission_service.UpdatePermissionRequest], gag_permission.Permission
+    ]:
+        r"""Return a callable for the update permission method over gRPC.
+
+        Updates the permission.
+
+        Returns:
+            Callable[[~.UpdatePermissionRequest],
+                    ~.Permission]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "update_permission" not in self._stubs:
+            self._stubs["update_permission"] = self._logged_channel.unary_unary(
+                "/google.ai.generativelanguage.v1beta3.PermissionService/UpdatePermission",
+                request_serializer=permission_service.UpdatePermissionRequest.serialize,
+                response_deserializer=gag_permission.Permission.deserialize,
+            )
+        return self._stubs["update_permission"]
+
+    @property
+    def delete_permission(
+        self,
+    ) -> Callable[[permission_service.DeletePermissionRequest], empty_pb2.Empty]:
+        r"""Return a callable for the delete permission method over gRPC.
+
+        Deletes the permission.
+
+        Returns:
+            Callable[[~.DeletePermissionRequest],
+                    ~.Empty]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "delete_permission" not in self._stubs:
+            self._stubs["delete_permission"] = self._logged_channel.unary_unary(
+                "/google.ai.generativelanguage.v1beta3.PermissionService/DeletePermission",
+                request_serializer=permission_service.DeletePermissionRequest.serialize,
+                response_deserializer=empty_pb2.Empty.FromString,
+            )
+        return self._stubs["delete_permission"]
+
+    @property
+    def transfer_ownership(
+        self,
+    ) -> Callable[
+        [permission_service.TransferOwnershipRequest],
+        permission_service.TransferOwnershipResponse,
+    ]:
+        r"""Return a callable for the transfer ownership method over gRPC.
+
+        Transfers ownership of the tuned model.
+        This is the only way to change ownership of the tuned
+        model. The current owner will be downgraded to writer
+        role.
+
+        Returns:
+            Callable[[~.TransferOwnershipRequest],
+                    ~.TransferOwnershipResponse]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "transfer_ownership" not in self._stubs:
+            self._stubs["transfer_ownership"] = self._logged_channel.unary_unary(
+                "/google.ai.generativelanguage.v1beta3.PermissionService/TransferOwnership",
+                request_serializer=permission_service.TransferOwnershipRequest.serialize,
+                response_deserializer=permission_service.TransferOwnershipResponse.deserialize,
+            )
+        return self._stubs["transfer_ownership"]
+
+    def close(self):
+        self._logged_channel.close()
+
+    @property
+    def kind(self) -> str:
+        return "grpc"
+
+
+__all__ = ("PermissionServiceGrpcTransport",)

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/services/permission_service/transports/grpc_asyncio.py

@@ -0,0 +1,558 @@
+# -*- coding: utf-8 -*-
+# 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 inspect
+import json
+import logging as std_logging
+import pickle
+from typing import Awaitable, Callable, Dict, Optional, Sequence, Tuple, Union
+import warnings
+
+from google.api_core import exceptions as core_exceptions
+from google.api_core import gapic_v1, grpc_helpers_async
+from google.api_core import retry_async as retries
+from google.auth import credentials as ga_credentials  # type: ignore
+from google.auth.transport.grpc import SslCredentials  # type: ignore
+from google.longrunning import operations_pb2  # type: ignore
+from google.protobuf import empty_pb2  # type: ignore
+from google.protobuf.json_format import MessageToJson
+import google.protobuf.message
+import grpc  # type: ignore
+from grpc.experimental import aio  # type: ignore
+import proto  # type: ignore
+
+from google.ai.generativelanguage_v1beta3.types import permission as gag_permission
+from google.ai.generativelanguage_v1beta3.types import permission
+from google.ai.generativelanguage_v1beta3.types import permission_service
+
+from .base import DEFAULT_CLIENT_INFO, PermissionServiceTransport
+from .grpc import PermissionServiceGrpcTransport
+
+try:
+    from google.api_core import client_logging  # type: ignore
+
+    CLIENT_LOGGING_SUPPORTED = True  # pragma: NO COVER
+except ImportError:  # pragma: NO COVER
+    CLIENT_LOGGING_SUPPORTED = False
+
+_LOGGER = std_logging.getLogger(__name__)
+
+
+class _LoggingClientAIOInterceptor(
+    grpc.aio.UnaryUnaryClientInterceptor
+):  # pragma: NO COVER
+    async def intercept_unary_unary(self, continuation, client_call_details, request):
+        logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+            std_logging.DEBUG
+        )
+        if logging_enabled:  # pragma: NO COVER
+            request_metadata = client_call_details.metadata
+            if isinstance(request, proto.Message):
+                request_payload = type(request).to_json(request)
+            elif isinstance(request, google.protobuf.message.Message):
+                request_payload = MessageToJson(request)
+            else:
+                request_payload = f"{type(request).__name__}: {pickle.dumps(request)}"
+
+            request_metadata = {
+                key: value.decode("utf-8") if isinstance(value, bytes) else value
+                for key, value in request_metadata
+            }
+            grpc_request = {
+                "payload": request_payload,
+                "requestMethod": "grpc",
+                "metadata": dict(request_metadata),
+            }
+            _LOGGER.debug(
+                f"Sending request for {client_call_details.method}",
+                extra={
+                    "serviceName": "google.ai.generativelanguage.v1beta3.PermissionService",
+                    "rpcName": str(client_call_details.method),
+                    "request": grpc_request,
+                    "metadata": grpc_request["metadata"],
+                },
+            )
+        response = await continuation(client_call_details, request)
+        if logging_enabled:  # pragma: NO COVER
+            response_metadata = await response.trailing_metadata()
+            # Convert gRPC metadata `<class 'grpc.aio._metadata.Metadata'>` to list of tuples
+            metadata = (
+                dict([(k, str(v)) for k, v in response_metadata])
+                if response_metadata
+                else None
+            )
+            result = await response
+            if isinstance(result, proto.Message):
+                response_payload = type(result).to_json(result)
+            elif isinstance(result, google.protobuf.message.Message):
+                response_payload = MessageToJson(result)
+            else:
+                response_payload = f"{type(result).__name__}: {pickle.dumps(result)}"
+            grpc_response = {
+                "payload": response_payload,
+                "metadata": metadata,
+                "status": "OK",
+            }
+            _LOGGER.debug(
+                f"Received response to rpc {client_call_details.method}.",
+                extra={
+                    "serviceName": "google.ai.generativelanguage.v1beta3.PermissionService",
+                    "rpcName": str(client_call_details.method),
+                    "response": grpc_response,
+                    "metadata": grpc_response["metadata"],
+                },
+            )
+        return response
+
+
+class PermissionServiceGrpcAsyncIOTransport(PermissionServiceTransport):
+    """gRPC AsyncIO backend transport for PermissionService.
+
+    Provides methods for managing permissions to PaLM API
+    resources.
+
+    This class defines the same methods as the primary client, so the
+    primary client can load the underlying transport implementation
+    and call it.
+
+    It sends protocol buffers over the wire using gRPC (which is built on
+    top of HTTP/2); the ``grpcio`` package must be installed.
+    """
+
+    _grpc_channel: aio.Channel
+    _stubs: Dict[str, Callable] = {}
+
+    @classmethod
+    def create_channel(
+        cls,
+        host: str = "generativelanguage.googleapis.com",
+        credentials: Optional[ga_credentials.Credentials] = None,
+        credentials_file: Optional[str] = None,
+        scopes: Optional[Sequence[str]] = None,
+        quota_project_id: Optional[str] = None,
+        **kwargs,
+    ) -> aio.Channel:
+        """Create and return a gRPC AsyncIO channel object.
+        Args:
+            host (Optional[str]): The host for the channel to use.
+            credentials (Optional[~.Credentials]): The
+                authorization credentials to attach to requests. These
+                credentials identify this application to the service. If
+                none are specified, the client will attempt to ascertain
+                the credentials from the environment.
+            credentials_file (Optional[str]): A file with credentials that can
+                be loaded with :func:`google.auth.load_credentials_from_file`.
+            scopes (Optional[Sequence[str]]): A optional list of scopes needed for this
+                service. These are only used when credentials are not specified and
+                are passed to :func:`google.auth.default`.
+            quota_project_id (Optional[str]): An optional project to use for billing
+                and quota.
+            kwargs (Optional[dict]): Keyword arguments, which are passed to the
+                channel creation.
+        Returns:
+            aio.Channel: A gRPC AsyncIO channel object.
+        """
+
+        return grpc_helpers_async.create_channel(
+            host,
+            credentials=credentials,
+            credentials_file=credentials_file,
+            quota_project_id=quota_project_id,
+            default_scopes=cls.AUTH_SCOPES,
+            scopes=scopes,
+            default_host=cls.DEFAULT_HOST,
+            **kwargs,
+        )
+
+    def __init__(
+        self,
+        *,
+        host: str = "generativelanguage.googleapis.com",
+        credentials: Optional[ga_credentials.Credentials] = None,
+        credentials_file: Optional[str] = None,
+        scopes: Optional[Sequence[str]] = None,
+        channel: Optional[Union[aio.Channel, Callable[..., aio.Channel]]] = None,
+        api_mtls_endpoint: Optional[str] = None,
+        client_cert_source: Optional[Callable[[], Tuple[bytes, bytes]]] = None,
+        ssl_channel_credentials: Optional[grpc.ChannelCredentials] = None,
+        client_cert_source_for_mtls: Optional[Callable[[], Tuple[bytes, bytes]]] = None,
+        quota_project_id: Optional[str] = None,
+        client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
+        always_use_jwt_access: Optional[bool] = False,
+        api_audience: Optional[str] = None,
+    ) -> None:
+        """Instantiate the transport.
+
+        Args:
+            host (Optional[str]):
+                 The hostname to connect to (default: 'generativelanguage.googleapis.com').
+            credentials (Optional[google.auth.credentials.Credentials]): The
+                authorization credentials to attach to requests. These
+                credentials identify the application to the service; if none
+                are specified, the client will attempt to ascertain the
+                credentials from the environment.
+                This argument is ignored if a ``channel`` instance is provided.
+            credentials_file (Optional[str]): A file with credentials that can
+                be loaded with :func:`google.auth.load_credentials_from_file`.
+                This argument is ignored if a ``channel`` instance is provided.
+            scopes (Optional[Sequence[str]]): A optional list of scopes needed for this
+                service. These are only used when credentials are not specified and
+                are passed to :func:`google.auth.default`.
+            channel (Optional[Union[aio.Channel, Callable[..., aio.Channel]]]):
+                A ``Channel`` instance through which to make calls, or a Callable
+                that constructs and returns one. If set to None, ``self.create_channel``
+                is used to create the channel. If a Callable is given, it will be called
+                with the same arguments as used in ``self.create_channel``.
+            api_mtls_endpoint (Optional[str]): Deprecated. The mutual TLS endpoint.
+                If provided, it overrides the ``host`` argument and tries to create
+                a mutual TLS channel with client SSL credentials from
+                ``client_cert_source`` or application default SSL credentials.
+            client_cert_source (Optional[Callable[[], Tuple[bytes, bytes]]]):
+                Deprecated. A callback to provide client SSL certificate bytes and
+                private key bytes, both in PEM format. It is ignored if
+                ``api_mtls_endpoint`` is None.
+            ssl_channel_credentials (grpc.ChannelCredentials): SSL credentials
+                for the grpc channel. It is ignored if a ``channel`` instance is provided.
+            client_cert_source_for_mtls (Optional[Callable[[], Tuple[bytes, bytes]]]):
+                A callback to provide client certificate bytes and private key bytes,
+                both in PEM format. It is used to configure a mutual TLS channel. It is
+                ignored if a ``channel`` instance or ``ssl_channel_credentials`` is provided.
+            quota_project_id (Optional[str]): An optional project to use for billing
+                and quota.
+            client_info (google.api_core.gapic_v1.client_info.ClientInfo):
+                The client info used to send a user-agent string along with
+                API requests. If ``None``, then default info will be used.
+                Generally, you only need to set this if you're developing
+                your own client library.
+            always_use_jwt_access (Optional[bool]): Whether self signed JWT should
+                be used for service account credentials.
+
+        Raises:
+            google.auth.exceptions.MutualTlsChannelError: If mutual TLS transport
+              creation failed for any reason.
+          google.api_core.exceptions.DuplicateCredentialArgs: If both ``credentials``
+              and ``credentials_file`` are passed.
+        """
+        self._grpc_channel = None
+        self._ssl_channel_credentials = ssl_channel_credentials
+        self._stubs: Dict[str, Callable] = {}
+
+        if api_mtls_endpoint:
+            warnings.warn("api_mtls_endpoint is deprecated", DeprecationWarning)
+        if client_cert_source:
+            warnings.warn("client_cert_source is deprecated", DeprecationWarning)
+
+        if isinstance(channel, aio.Channel):
+            # Ignore credentials if a channel was passed.
+            credentials = None
+            self._ignore_credentials = True
+            # If a channel was explicitly provided, set it.
+            self._grpc_channel = channel
+            self._ssl_channel_credentials = None
+        else:
+            if api_mtls_endpoint:
+                host = api_mtls_endpoint
+
+                # Create SSL credentials with client_cert_source or application
+                # default SSL credentials.
+                if client_cert_source:
+                    cert, key = client_cert_source()
+                    self._ssl_channel_credentials = grpc.ssl_channel_credentials(
+                        certificate_chain=cert, private_key=key
+                    )
+                else:
+                    self._ssl_channel_credentials = SslCredentials().ssl_credentials
+
+            else:
+                if client_cert_source_for_mtls and not ssl_channel_credentials:
+                    cert, key = client_cert_source_for_mtls()
+                    self._ssl_channel_credentials = grpc.ssl_channel_credentials(
+                        certificate_chain=cert, private_key=key
+                    )
+
+        # The base transport sets the host, credentials and scopes
+        super().__init__(
+            host=host,
+            credentials=credentials,
+            credentials_file=credentials_file,
+            scopes=scopes,
+            quota_project_id=quota_project_id,
+            client_info=client_info,
+            always_use_jwt_access=always_use_jwt_access,
+            api_audience=api_audience,
+        )
+
+        if not self._grpc_channel:
+            # initialize with the provided callable or the default channel
+            channel_init = channel or type(self).create_channel
+            self._grpc_channel = channel_init(
+                self._host,
+                # use the credentials which are saved
+                credentials=self._credentials,
+                # Set ``credentials_file`` to ``None`` here as
+                # the credentials that we saved earlier should be used.
+                credentials_file=None,
+                scopes=self._scopes,
+                ssl_credentials=self._ssl_channel_credentials,
+                quota_project_id=quota_project_id,
+                options=[
+                    ("grpc.max_send_message_length", -1),
+                    ("grpc.max_receive_message_length", -1),
+                ],
+            )
+
+        self._interceptor = _LoggingClientAIOInterceptor()
+        self._grpc_channel._unary_unary_interceptors.append(self._interceptor)
+        self._logged_channel = self._grpc_channel
+        self._wrap_with_kind = (
+            "kind" in inspect.signature(gapic_v1.method_async.wrap_method).parameters
+        )
+        # Wrap messages. This must be done after self._logged_channel exists
+        self._prep_wrapped_messages(client_info)
+
+    @property
+    def grpc_channel(self) -> aio.Channel:
+        """Create the channel designed to connect to this service.
+
+        This property caches on the instance; repeated calls return
+        the same channel.
+        """
+        # Return the channel from cache.
+        return self._grpc_channel
+
+    @property
+    def create_permission(
+        self,
+    ) -> Callable[
+        [permission_service.CreatePermissionRequest],
+        Awaitable[gag_permission.Permission],
+    ]:
+        r"""Return a callable for the create permission method over gRPC.
+
+        Create a permission to a specific resource.
+
+        Returns:
+            Callable[[~.CreatePermissionRequest],
+                    Awaitable[~.Permission]]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "create_permission" not in self._stubs:
+            self._stubs["create_permission"] = self._logged_channel.unary_unary(
+                "/google.ai.generativelanguage.v1beta3.PermissionService/CreatePermission",
+                request_serializer=permission_service.CreatePermissionRequest.serialize,
+                response_deserializer=gag_permission.Permission.deserialize,
+            )
+        return self._stubs["create_permission"]
+
+    @property
+    def get_permission(
+        self,
+    ) -> Callable[
+        [permission_service.GetPermissionRequest], Awaitable[permission.Permission]
+    ]:
+        r"""Return a callable for the get permission method over gRPC.
+
+        Gets information about a specific Permission.
+
+        Returns:
+            Callable[[~.GetPermissionRequest],
+                    Awaitable[~.Permission]]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "get_permission" not in self._stubs:
+            self._stubs["get_permission"] = self._logged_channel.unary_unary(
+                "/google.ai.generativelanguage.v1beta3.PermissionService/GetPermission",
+                request_serializer=permission_service.GetPermissionRequest.serialize,
+                response_deserializer=permission.Permission.deserialize,
+            )
+        return self._stubs["get_permission"]
+
+    @property
+    def list_permissions(
+        self,
+    ) -> Callable[
+        [permission_service.ListPermissionsRequest],
+        Awaitable[permission_service.ListPermissionsResponse],
+    ]:
+        r"""Return a callable for the list permissions method over gRPC.
+
+        Lists permissions for the specific resource.
+
+        Returns:
+            Callable[[~.ListPermissionsRequest],
+                    Awaitable[~.ListPermissionsResponse]]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "list_permissions" not in self._stubs:
+            self._stubs["list_permissions"] = self._logged_channel.unary_unary(
+                "/google.ai.generativelanguage.v1beta3.PermissionService/ListPermissions",
+                request_serializer=permission_service.ListPermissionsRequest.serialize,
+                response_deserializer=permission_service.ListPermissionsResponse.deserialize,
+            )
+        return self._stubs["list_permissions"]
+
+    @property
+    def update_permission(
+        self,
+    ) -> Callable[
+        [permission_service.UpdatePermissionRequest],
+        Awaitable[gag_permission.Permission],
+    ]:
+        r"""Return a callable for the update permission method over gRPC.
+
+        Updates the permission.
+
+        Returns:
+            Callable[[~.UpdatePermissionRequest],
+                    Awaitable[~.Permission]]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "update_permission" not in self._stubs:
+            self._stubs["update_permission"] = self._logged_channel.unary_unary(
+                "/google.ai.generativelanguage.v1beta3.PermissionService/UpdatePermission",
+                request_serializer=permission_service.UpdatePermissionRequest.serialize,
+                response_deserializer=gag_permission.Permission.deserialize,
+            )
+        return self._stubs["update_permission"]
+
+    @property
+    def delete_permission(
+        self,
+    ) -> Callable[
+        [permission_service.DeletePermissionRequest], Awaitable[empty_pb2.Empty]
+    ]:
+        r"""Return a callable for the delete permission method over gRPC.
+
+        Deletes the permission.
+
+        Returns:
+            Callable[[~.DeletePermissionRequest],
+                    Awaitable[~.Empty]]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "delete_permission" not in self._stubs:
+            self._stubs["delete_permission"] = self._logged_channel.unary_unary(
+                "/google.ai.generativelanguage.v1beta3.PermissionService/DeletePermission",
+                request_serializer=permission_service.DeletePermissionRequest.serialize,
+                response_deserializer=empty_pb2.Empty.FromString,
+            )
+        return self._stubs["delete_permission"]
+
+    @property
+    def transfer_ownership(
+        self,
+    ) -> Callable[
+        [permission_service.TransferOwnershipRequest],
+        Awaitable[permission_service.TransferOwnershipResponse],
+    ]:
+        r"""Return a callable for the transfer ownership method over gRPC.
+
+        Transfers ownership of the tuned model.
+        This is the only way to change ownership of the tuned
+        model. The current owner will be downgraded to writer
+        role.
+
+        Returns:
+            Callable[[~.TransferOwnershipRequest],
+                    Awaitable[~.TransferOwnershipResponse]]:
+                A function that, when called, will call the underlying RPC
+                on the server.
+        """
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "transfer_ownership" not in self._stubs:
+            self._stubs["transfer_ownership"] = self._logged_channel.unary_unary(
+                "/google.ai.generativelanguage.v1beta3.PermissionService/TransferOwnership",
+                request_serializer=permission_service.TransferOwnershipRequest.serialize,
+                response_deserializer=permission_service.TransferOwnershipResponse.deserialize,
+            )
+        return self._stubs["transfer_ownership"]
+
+    def _prep_wrapped_messages(self, client_info):
+        """Precompute the wrapped methods, overriding the base class method to use async wrappers."""
+        self._wrapped_methods = {
+            self.create_permission: self._wrap_method(
+                self.create_permission,
+                default_timeout=None,
+                client_info=client_info,
+            ),
+            self.get_permission: self._wrap_method(
+                self.get_permission,
+                default_timeout=None,
+                client_info=client_info,
+            ),
+            self.list_permissions: self._wrap_method(
+                self.list_permissions,
+                default_timeout=None,
+                client_info=client_info,
+            ),
+            self.update_permission: self._wrap_method(
+                self.update_permission,
+                default_timeout=None,
+                client_info=client_info,
+            ),
+            self.delete_permission: self._wrap_method(
+                self.delete_permission,
+                default_timeout=None,
+                client_info=client_info,
+            ),
+            self.transfer_ownership: self._wrap_method(
+                self.transfer_ownership,
+                default_timeout=None,
+                client_info=client_info,
+            ),
+        }
+
+    def _wrap_method(self, func, *args, **kwargs):
+        if self._wrap_with_kind:  # pragma: NO COVER
+            kwargs["kind"] = self.kind
+        return gapic_v1.method_async.wrap_method(func, *args, **kwargs)
+
+    def close(self):
+        return self._logged_channel.close()
+
+    @property
+    def kind(self) -> str:
+        return "grpc_asyncio"
+
+
+__all__ = ("PermissionServiceGrpcAsyncIOTransport",)

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/services/permission_service/transports/rest.py

@@ -0,0 +1,1340 @@
+# -*- coding: utf-8 -*-
+# 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 dataclasses
+import json  # type: ignore
+import logging
+from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union
+import warnings
+
+from google.api_core import exceptions as core_exceptions
+from google.api_core import gapic_v1, rest_helpers, rest_streaming
+from google.api_core import retry as retries
+from google.auth import credentials as ga_credentials  # type: ignore
+from google.auth.transport.requests import AuthorizedSession  # type: ignore
+from google.longrunning import operations_pb2  # type: ignore
+from google.protobuf import empty_pb2  # type: ignore
+from google.protobuf import json_format
+from requests import __version__ as requests_version
+
+from google.ai.generativelanguage_v1beta3.types import permission as gag_permission
+from google.ai.generativelanguage_v1beta3.types import permission
+from google.ai.generativelanguage_v1beta3.types import permission_service
+
+from .base import DEFAULT_CLIENT_INFO as BASE_DEFAULT_CLIENT_INFO
+from .rest_base import _BasePermissionServiceRestTransport
+
+try:
+    OptionalRetry = Union[retries.Retry, gapic_v1.method._MethodDefault, None]
+except AttributeError:  # pragma: NO COVER
+    OptionalRetry = Union[retries.Retry, object, None]  # type: ignore
+
+try:
+    from google.api_core import client_logging  # type: ignore
+
+    CLIENT_LOGGING_SUPPORTED = True  # pragma: NO COVER
+except ImportError:  # pragma: NO COVER
+    CLIENT_LOGGING_SUPPORTED = False
+
+_LOGGER = logging.getLogger(__name__)
+
+DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
+    gapic_version=BASE_DEFAULT_CLIENT_INFO.gapic_version,
+    grpc_version=None,
+    rest_version=f"requests@{requests_version}",
+)
+
+
+class PermissionServiceRestInterceptor:
+    """Interceptor for PermissionService.
+
+    Interceptors are used to manipulate requests, request metadata, and responses
+    in arbitrary ways.
+    Example use cases include:
+    * Logging
+    * Verifying requests according to service or custom semantics
+    * Stripping extraneous information from responses
+
+    These use cases and more can be enabled by injecting an
+    instance of a custom subclass when constructing the PermissionServiceRestTransport.
+
+    .. code-block:: python
+        class MyCustomPermissionServiceInterceptor(PermissionServiceRestInterceptor):
+            def pre_create_permission(self, request, metadata):
+                logging.log(f"Received request: {request}")
+                return request, metadata
+
+            def post_create_permission(self, response):
+                logging.log(f"Received response: {response}")
+                return response
+
+            def pre_delete_permission(self, request, metadata):
+                logging.log(f"Received request: {request}")
+                return request, metadata
+
+            def pre_get_permission(self, request, metadata):
+                logging.log(f"Received request: {request}")
+                return request, metadata
+
+            def post_get_permission(self, response):
+                logging.log(f"Received response: {response}")
+                return response
+
+            def pre_list_permissions(self, request, metadata):
+                logging.log(f"Received request: {request}")
+                return request, metadata
+
+            def post_list_permissions(self, response):
+                logging.log(f"Received response: {response}")
+                return response
+
+            def pre_transfer_ownership(self, request, metadata):
+                logging.log(f"Received request: {request}")
+                return request, metadata
+
+            def post_transfer_ownership(self, response):
+                logging.log(f"Received response: {response}")
+                return response
+
+            def pre_update_permission(self, request, metadata):
+                logging.log(f"Received request: {request}")
+                return request, metadata
+
+            def post_update_permission(self, response):
+                logging.log(f"Received response: {response}")
+                return response
+
+        transport = PermissionServiceRestTransport(interceptor=MyCustomPermissionServiceInterceptor())
+        client = PermissionServiceClient(transport=transport)
+
+
+    """
+
+    def pre_create_permission(
+        self,
+        request: permission_service.CreatePermissionRequest,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]],
+    ) -> Tuple[
+        permission_service.CreatePermissionRequest,
+        Sequence[Tuple[str, Union[str, bytes]]],
+    ]:
+        """Pre-rpc interceptor for create_permission
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the PermissionService server.
+        """
+        return request, metadata
+
+    def post_create_permission(
+        self, response: gag_permission.Permission
+    ) -> gag_permission.Permission:
+        """Post-rpc interceptor for create_permission
+
+        Override in a subclass to manipulate the response
+        after it is returned by the PermissionService server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_delete_permission(
+        self,
+        request: permission_service.DeletePermissionRequest,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]],
+    ) -> Tuple[
+        permission_service.DeletePermissionRequest,
+        Sequence[Tuple[str, Union[str, bytes]]],
+    ]:
+        """Pre-rpc interceptor for delete_permission
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the PermissionService server.
+        """
+        return request, metadata
+
+    def pre_get_permission(
+        self,
+        request: permission_service.GetPermissionRequest,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]],
+    ) -> Tuple[
+        permission_service.GetPermissionRequest, Sequence[Tuple[str, Union[str, bytes]]]
+    ]:
+        """Pre-rpc interceptor for get_permission
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the PermissionService server.
+        """
+        return request, metadata
+
+    def post_get_permission(
+        self, response: permission.Permission
+    ) -> permission.Permission:
+        """Post-rpc interceptor for get_permission
+
+        Override in a subclass to manipulate the response
+        after it is returned by the PermissionService server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_list_permissions(
+        self,
+        request: permission_service.ListPermissionsRequest,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]],
+    ) -> Tuple[
+        permission_service.ListPermissionsRequest,
+        Sequence[Tuple[str, Union[str, bytes]]],
+    ]:
+        """Pre-rpc interceptor for list_permissions
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the PermissionService server.
+        """
+        return request, metadata
+
+    def post_list_permissions(
+        self, response: permission_service.ListPermissionsResponse
+    ) -> permission_service.ListPermissionsResponse:
+        """Post-rpc interceptor for list_permissions
+
+        Override in a subclass to manipulate the response
+        after it is returned by the PermissionService server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_transfer_ownership(
+        self,
+        request: permission_service.TransferOwnershipRequest,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]],
+    ) -> Tuple[
+        permission_service.TransferOwnershipRequest,
+        Sequence[Tuple[str, Union[str, bytes]]],
+    ]:
+        """Pre-rpc interceptor for transfer_ownership
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the PermissionService server.
+        """
+        return request, metadata
+
+    def post_transfer_ownership(
+        self, response: permission_service.TransferOwnershipResponse
+    ) -> permission_service.TransferOwnershipResponse:
+        """Post-rpc interceptor for transfer_ownership
+
+        Override in a subclass to manipulate the response
+        after it is returned by the PermissionService server but before
+        it is returned to user code.
+        """
+        return response
+
+    def pre_update_permission(
+        self,
+        request: permission_service.UpdatePermissionRequest,
+        metadata: Sequence[Tuple[str, Union[str, bytes]]],
+    ) -> Tuple[
+        permission_service.UpdatePermissionRequest,
+        Sequence[Tuple[str, Union[str, bytes]]],
+    ]:
+        """Pre-rpc interceptor for update_permission
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the PermissionService server.
+        """
+        return request, metadata
+
+    def post_update_permission(
+        self, response: gag_permission.Permission
+    ) -> gag_permission.Permission:
+        """Post-rpc interceptor for update_permission
+
+        Override in a subclass to manipulate the response
+        after it is returned by the PermissionService server but before
+        it is returned to user code.
+        """
+        return response
+
+
+@dataclasses.dataclass
+class PermissionServiceRestStub:
+    _session: AuthorizedSession
+    _host: str
+    _interceptor: PermissionServiceRestInterceptor
+
+
+class PermissionServiceRestTransport(_BasePermissionServiceRestTransport):
+    """REST backend synchronous transport for PermissionService.
+
+    Provides methods for managing permissions to PaLM API
+    resources.
+
+    This class defines the same methods as the primary client, so the
+    primary client can load the underlying transport implementation
+    and call it.
+
+    It sends JSON representations of protocol buffers over HTTP/1.1
+    """
+
+    def __init__(
+        self,
+        *,
+        host: str = "generativelanguage.googleapis.com",
+        credentials: Optional[ga_credentials.Credentials] = None,
+        credentials_file: Optional[str] = None,
+        scopes: Optional[Sequence[str]] = None,
+        client_cert_source_for_mtls: Optional[Callable[[], Tuple[bytes, bytes]]] = None,
+        quota_project_id: Optional[str] = None,
+        client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
+        always_use_jwt_access: Optional[bool] = False,
+        url_scheme: str = "https",
+        interceptor: Optional[PermissionServiceRestInterceptor] = None,
+        api_audience: Optional[str] = None,
+    ) -> None:
+        """Instantiate the transport.
+
+        Args:
+            host (Optional[str]):
+                 The hostname to connect to (default: 'generativelanguage.googleapis.com').
+            credentials (Optional[google.auth.credentials.Credentials]): The
+                authorization credentials to attach to requests. These
+                credentials identify the application to the service; if none
+                are specified, the client will attempt to ascertain the
+                credentials from the environment.
+
+            credentials_file (Optional[str]): A file with credentials that can
+                be loaded with :func:`google.auth.load_credentials_from_file`.
+                This argument is ignored if ``channel`` is provided.
+            scopes (Optional(Sequence[str])): A list of scopes. This argument is
+                ignored if ``channel`` is provided.
+            client_cert_source_for_mtls (Callable[[], Tuple[bytes, bytes]]): Client
+                certificate to configure mutual TLS HTTP channel. It is ignored
+                if ``channel`` is provided.
+            quota_project_id (Optional[str]): An optional project to use for billing
+                and quota.
+            client_info (google.api_core.gapic_v1.client_info.ClientInfo):
+                The client info used to send a user-agent string along with
+                API requests. If ``None``, then default info will be used.
+                Generally, you only need to set this if you are developing
+                your own client library.
+            always_use_jwt_access (Optional[bool]): Whether self signed JWT should
+                be used for service account credentials.
+            url_scheme: the protocol scheme for the API endpoint.  Normally
+                "https", but for testing or local servers,
+                "http" can be specified.
+        """
+        # Run the base constructor
+        # TODO(yon-mg): resolve other ctor params i.e. scopes, quota, etc.
+        # TODO: When custom host (api_endpoint) is set, `scopes` must *also* be set on the
+        # credentials object
+        super().__init__(
+            host=host,
+            credentials=credentials,
+            client_info=client_info,
+            always_use_jwt_access=always_use_jwt_access,
+            url_scheme=url_scheme,
+            api_audience=api_audience,
+        )
+        self._session = AuthorizedSession(
+            self._credentials, default_host=self.DEFAULT_HOST
+        )
+        if client_cert_source_for_mtls:
+            self._session.configure_mtls_channel(client_cert_source_for_mtls)
+        self._interceptor = interceptor or PermissionServiceRestInterceptor()
+        self._prep_wrapped_messages(client_info)
+
+    class _CreatePermission(
+        _BasePermissionServiceRestTransport._BaseCreatePermission,
+        PermissionServiceRestStub,
+    ):
+        def __hash__(self):
+            return hash("PermissionServiceRestTransport.CreatePermission")
+
+        @staticmethod
+        def _get_response(
+            host,
+            metadata,
+            query_params,
+            session,
+            timeout,
+            transcoded_request,
+            body=None,
+        ):
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+            response = getattr(session, method)(
+                "{host}{uri}".format(host=host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params, strict=True),
+                data=body,
+            )
+            return response
+
+        def __call__(
+            self,
+            request: permission_service.CreatePermissionRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
+        ) -> gag_permission.Permission:
+            r"""Call the create permission method over HTTP.
+
+            Args:
+                request (~.permission_service.CreatePermissionRequest):
+                    The request object. Request to create a ``Permission``.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                    sent along with the request as metadata. Normally, each value must be of type `str`,
+                    but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                    be of type `bytes`.
+
+            Returns:
+                ~.gag_permission.Permission:
+                    Permission resource grants user,
+                group or the rest of the world access to
+                the PaLM API resource (e.g. a tuned
+                model, file).
+
+                A role is a collection of permitted
+                operations that allows users to perform
+                specific actions on PaLM API resources.
+                To make them available to users, groups,
+                or service accounts, you assign roles.
+                When you assign a role, you grant
+                permissions that the role contains.
+
+                There are three concentric roles. Each
+                role is a superset of the previous
+                role's permitted operations:
+
+                 - reader can use the resource (e.g.
+                  tuned model) for inference
+                 - writer has reader's permissions and
+                  additionally can edit and share
+                 - owner has writer's permissions and
+                  additionally can delete
+
+            """
+
+            http_options = (
+                _BasePermissionServiceRestTransport._BaseCreatePermission._get_http_options()
+            )
+
+            request, metadata = self._interceptor.pre_create_permission(
+                request, metadata
+            )
+            transcoded_request = _BasePermissionServiceRestTransport._BaseCreatePermission._get_transcoded_request(
+                http_options, request
+            )
+
+            body = _BasePermissionServiceRestTransport._BaseCreatePermission._get_request_body_json(
+                transcoded_request
+            )
+
+            # Jsonify the query params
+            query_params = _BasePermissionServiceRestTransport._BaseCreatePermission._get_query_params_json(
+                transcoded_request
+            )
+
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                logging.DEBUG
+            ):  # pragma: NO COVER
+                request_url = "{host}{uri}".format(
+                    host=self._host, uri=transcoded_request["uri"]
+                )
+                method = transcoded_request["method"]
+                try:
+                    request_payload = type(request).to_json(request)
+                except:
+                    request_payload = None
+                http_request = {
+                    "payload": request_payload,
+                    "requestMethod": method,
+                    "requestUrl": request_url,
+                    "headers": dict(metadata),
+                }
+                _LOGGER.debug(
+                    f"Sending request for google.ai.generativelanguage_v1beta3.PermissionServiceClient.CreatePermission",
+                    extra={
+                        "serviceName": "google.ai.generativelanguage.v1beta3.PermissionService",
+                        "rpcName": "CreatePermission",
+                        "httpRequest": http_request,
+                        "metadata": http_request["headers"],
+                    },
+                )
+
+            # Send the request
+            response = PermissionServiceRestTransport._CreatePermission._get_response(
+                self._host,
+                metadata,
+                query_params,
+                self._session,
+                timeout,
+                transcoded_request,
+                body,
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            # Return the response
+            resp = gag_permission.Permission()
+            pb_resp = gag_permission.Permission.pb(resp)
+
+            json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
+
+            resp = self._interceptor.post_create_permission(resp)
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                logging.DEBUG
+            ):  # pragma: NO COVER
+                try:
+                    response_payload = gag_permission.Permission.to_json(response)
+                except:
+                    response_payload = None
+                http_response = {
+                    "payload": response_payload,
+                    "headers": dict(response.headers),
+                    "status": response.status_code,
+                }
+                _LOGGER.debug(
+                    "Received response for google.ai.generativelanguage_v1beta3.PermissionServiceClient.create_permission",
+                    extra={
+                        "serviceName": "google.ai.generativelanguage.v1beta3.PermissionService",
+                        "rpcName": "CreatePermission",
+                        "metadata": http_response["headers"],
+                        "httpResponse": http_response,
+                    },
+                )
+            return resp
+
+    class _DeletePermission(
+        _BasePermissionServiceRestTransport._BaseDeletePermission,
+        PermissionServiceRestStub,
+    ):
+        def __hash__(self):
+            return hash("PermissionServiceRestTransport.DeletePermission")
+
+        @staticmethod
+        def _get_response(
+            host,
+            metadata,
+            query_params,
+            session,
+            timeout,
+            transcoded_request,
+            body=None,
+        ):
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+            response = getattr(session, method)(
+                "{host}{uri}".format(host=host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params, strict=True),
+            )
+            return response
+
+        def __call__(
+            self,
+            request: permission_service.DeletePermissionRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
+        ):
+            r"""Call the delete permission method over HTTP.
+
+            Args:
+                request (~.permission_service.DeletePermissionRequest):
+                    The request object. Request to delete the ``Permission``.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                    sent along with the request as metadata. Normally, each value must be of type `str`,
+                    but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                    be of type `bytes`.
+            """
+
+            http_options = (
+                _BasePermissionServiceRestTransport._BaseDeletePermission._get_http_options()
+            )
+
+            request, metadata = self._interceptor.pre_delete_permission(
+                request, metadata
+            )
+            transcoded_request = _BasePermissionServiceRestTransport._BaseDeletePermission._get_transcoded_request(
+                http_options, request
+            )
+
+            # Jsonify the query params
+            query_params = _BasePermissionServiceRestTransport._BaseDeletePermission._get_query_params_json(
+                transcoded_request
+            )
+
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                logging.DEBUG
+            ):  # pragma: NO COVER
+                request_url = "{host}{uri}".format(
+                    host=self._host, uri=transcoded_request["uri"]
+                )
+                method = transcoded_request["method"]
+                try:
+                    request_payload = json_format.MessageToJson(request)
+                except:
+                    request_payload = None
+                http_request = {
+                    "payload": request_payload,
+                    "requestMethod": method,
+                    "requestUrl": request_url,
+                    "headers": dict(metadata),
+                }
+                _LOGGER.debug(
+                    f"Sending request for google.ai.generativelanguage_v1beta3.PermissionServiceClient.DeletePermission",
+                    extra={
+                        "serviceName": "google.ai.generativelanguage.v1beta3.PermissionService",
+                        "rpcName": "DeletePermission",
+                        "httpRequest": http_request,
+                        "metadata": http_request["headers"],
+                    },
+                )
+
+            # Send the request
+            response = PermissionServiceRestTransport._DeletePermission._get_response(
+                self._host,
+                metadata,
+                query_params,
+                self._session,
+                timeout,
+                transcoded_request,
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+    class _GetPermission(
+        _BasePermissionServiceRestTransport._BaseGetPermission,
+        PermissionServiceRestStub,
+    ):
+        def __hash__(self):
+            return hash("PermissionServiceRestTransport.GetPermission")
+
+        @staticmethod
+        def _get_response(
+            host,
+            metadata,
+            query_params,
+            session,
+            timeout,
+            transcoded_request,
+            body=None,
+        ):
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+            response = getattr(session, method)(
+                "{host}{uri}".format(host=host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params, strict=True),
+            )
+            return response
+
+        def __call__(
+            self,
+            request: permission_service.GetPermissionRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
+        ) -> permission.Permission:
+            r"""Call the get permission method over HTTP.
+
+            Args:
+                request (~.permission_service.GetPermissionRequest):
+                    The request object. Request for getting information about a specific
+                ``Permission``.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                    sent along with the request as metadata. Normally, each value must be of type `str`,
+                    but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                    be of type `bytes`.
+
+            Returns:
+                ~.permission.Permission:
+                    Permission resource grants user,
+                group or the rest of the world access to
+                the PaLM API resource (e.g. a tuned
+                model, file).
+
+                A role is a collection of permitted
+                operations that allows users to perform
+                specific actions on PaLM API resources.
+                To make them available to users, groups,
+                or service accounts, you assign roles.
+                When you assign a role, you grant
+                permissions that the role contains.
+
+                There are three concentric roles. Each
+                role is a superset of the previous
+                role's permitted operations:
+
+                 - reader can use the resource (e.g.
+                  tuned model) for inference
+                 - writer has reader's permissions and
+                  additionally can edit and share
+                 - owner has writer's permissions and
+                  additionally can delete
+
+            """
+
+            http_options = (
+                _BasePermissionServiceRestTransport._BaseGetPermission._get_http_options()
+            )
+
+            request, metadata = self._interceptor.pre_get_permission(request, metadata)
+            transcoded_request = _BasePermissionServiceRestTransport._BaseGetPermission._get_transcoded_request(
+                http_options, request
+            )
+
+            # Jsonify the query params
+            query_params = _BasePermissionServiceRestTransport._BaseGetPermission._get_query_params_json(
+                transcoded_request
+            )
+
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                logging.DEBUG
+            ):  # pragma: NO COVER
+                request_url = "{host}{uri}".format(
+                    host=self._host, uri=transcoded_request["uri"]
+                )
+                method = transcoded_request["method"]
+                try:
+                    request_payload = type(request).to_json(request)
+                except:
+                    request_payload = None
+                http_request = {
+                    "payload": request_payload,
+                    "requestMethod": method,
+                    "requestUrl": request_url,
+                    "headers": dict(metadata),
+                }
+                _LOGGER.debug(
+                    f"Sending request for google.ai.generativelanguage_v1beta3.PermissionServiceClient.GetPermission",
+                    extra={
+                        "serviceName": "google.ai.generativelanguage.v1beta3.PermissionService",
+                        "rpcName": "GetPermission",
+                        "httpRequest": http_request,
+                        "metadata": http_request["headers"],
+                    },
+                )
+
+            # Send the request
+            response = PermissionServiceRestTransport._GetPermission._get_response(
+                self._host,
+                metadata,
+                query_params,
+                self._session,
+                timeout,
+                transcoded_request,
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            # Return the response
+            resp = permission.Permission()
+            pb_resp = permission.Permission.pb(resp)
+
+            json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
+
+            resp = self._interceptor.post_get_permission(resp)
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                logging.DEBUG
+            ):  # pragma: NO COVER
+                try:
+                    response_payload = permission.Permission.to_json(response)
+                except:
+                    response_payload = None
+                http_response = {
+                    "payload": response_payload,
+                    "headers": dict(response.headers),
+                    "status": response.status_code,
+                }
+                _LOGGER.debug(
+                    "Received response for google.ai.generativelanguage_v1beta3.PermissionServiceClient.get_permission",
+                    extra={
+                        "serviceName": "google.ai.generativelanguage.v1beta3.PermissionService",
+                        "rpcName": "GetPermission",
+                        "metadata": http_response["headers"],
+                        "httpResponse": http_response,
+                    },
+                )
+            return resp
+
+    class _ListPermissions(
+        _BasePermissionServiceRestTransport._BaseListPermissions,
+        PermissionServiceRestStub,
+    ):
+        def __hash__(self):
+            return hash("PermissionServiceRestTransport.ListPermissions")
+
+        @staticmethod
+        def _get_response(
+            host,
+            metadata,
+            query_params,
+            session,
+            timeout,
+            transcoded_request,
+            body=None,
+        ):
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+            response = getattr(session, method)(
+                "{host}{uri}".format(host=host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params, strict=True),
+            )
+            return response
+
+        def __call__(
+            self,
+            request: permission_service.ListPermissionsRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
+        ) -> permission_service.ListPermissionsResponse:
+            r"""Call the list permissions method over HTTP.
+
+            Args:
+                request (~.permission_service.ListPermissionsRequest):
+                    The request object. Request for listing permissions.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                    sent along with the request as metadata. Normally, each value must be of type `str`,
+                    but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                    be of type `bytes`.
+
+            Returns:
+                ~.permission_service.ListPermissionsResponse:
+                    Response from ``ListPermissions`` containing a paginated
+                list of permissions.
+
+            """
+
+            http_options = (
+                _BasePermissionServiceRestTransport._BaseListPermissions._get_http_options()
+            )
+
+            request, metadata = self._interceptor.pre_list_permissions(
+                request, metadata
+            )
+            transcoded_request = _BasePermissionServiceRestTransport._BaseListPermissions._get_transcoded_request(
+                http_options, request
+            )
+
+            # Jsonify the query params
+            query_params = _BasePermissionServiceRestTransport._BaseListPermissions._get_query_params_json(
+                transcoded_request
+            )
+
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                logging.DEBUG
+            ):  # pragma: NO COVER
+                request_url = "{host}{uri}".format(
+                    host=self._host, uri=transcoded_request["uri"]
+                )
+                method = transcoded_request["method"]
+                try:
+                    request_payload = type(request).to_json(request)
+                except:
+                    request_payload = None
+                http_request = {
+                    "payload": request_payload,
+                    "requestMethod": method,
+                    "requestUrl": request_url,
+                    "headers": dict(metadata),
+                }
+                _LOGGER.debug(
+                    f"Sending request for google.ai.generativelanguage_v1beta3.PermissionServiceClient.ListPermissions",
+                    extra={
+                        "serviceName": "google.ai.generativelanguage.v1beta3.PermissionService",
+                        "rpcName": "ListPermissions",
+                        "httpRequest": http_request,
+                        "metadata": http_request["headers"],
+                    },
+                )
+
+            # Send the request
+            response = PermissionServiceRestTransport._ListPermissions._get_response(
+                self._host,
+                metadata,
+                query_params,
+                self._session,
+                timeout,
+                transcoded_request,
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            # Return the response
+            resp = permission_service.ListPermissionsResponse()
+            pb_resp = permission_service.ListPermissionsResponse.pb(resp)
+
+            json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
+
+            resp = self._interceptor.post_list_permissions(resp)
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                logging.DEBUG
+            ):  # pragma: NO COVER
+                try:
+                    response_payload = (
+                        permission_service.ListPermissionsResponse.to_json(response)
+                    )
+                except:
+                    response_payload = None
+                http_response = {
+                    "payload": response_payload,
+                    "headers": dict(response.headers),
+                    "status": response.status_code,
+                }
+                _LOGGER.debug(
+                    "Received response for google.ai.generativelanguage_v1beta3.PermissionServiceClient.list_permissions",
+                    extra={
+                        "serviceName": "google.ai.generativelanguage.v1beta3.PermissionService",
+                        "rpcName": "ListPermissions",
+                        "metadata": http_response["headers"],
+                        "httpResponse": http_response,
+                    },
+                )
+            return resp
+
+    class _TransferOwnership(
+        _BasePermissionServiceRestTransport._BaseTransferOwnership,
+        PermissionServiceRestStub,
+    ):
+        def __hash__(self):
+            return hash("PermissionServiceRestTransport.TransferOwnership")
+
+        @staticmethod
+        def _get_response(
+            host,
+            metadata,
+            query_params,
+            session,
+            timeout,
+            transcoded_request,
+            body=None,
+        ):
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+            response = getattr(session, method)(
+                "{host}{uri}".format(host=host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params, strict=True),
+                data=body,
+            )
+            return response
+
+        def __call__(
+            self,
+            request: permission_service.TransferOwnershipRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
+        ) -> permission_service.TransferOwnershipResponse:
+            r"""Call the transfer ownership method over HTTP.
+
+            Args:
+                request (~.permission_service.TransferOwnershipRequest):
+                    The request object. Request to transfer the ownership of
+                the tuned model.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                    sent along with the request as metadata. Normally, each value must be of type `str`,
+                    but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                    be of type `bytes`.
+
+            Returns:
+                ~.permission_service.TransferOwnershipResponse:
+                    Response from ``TransferOwnership``.
+            """
+
+            http_options = (
+                _BasePermissionServiceRestTransport._BaseTransferOwnership._get_http_options()
+            )
+
+            request, metadata = self._interceptor.pre_transfer_ownership(
+                request, metadata
+            )
+            transcoded_request = _BasePermissionServiceRestTransport._BaseTransferOwnership._get_transcoded_request(
+                http_options, request
+            )
+
+            body = _BasePermissionServiceRestTransport._BaseTransferOwnership._get_request_body_json(
+                transcoded_request
+            )
+
+            # Jsonify the query params
+            query_params = _BasePermissionServiceRestTransport._BaseTransferOwnership._get_query_params_json(
+                transcoded_request
+            )
+
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                logging.DEBUG
+            ):  # pragma: NO COVER
+                request_url = "{host}{uri}".format(
+                    host=self._host, uri=transcoded_request["uri"]
+                )
+                method = transcoded_request["method"]
+                try:
+                    request_payload = type(request).to_json(request)
+                except:
+                    request_payload = None
+                http_request = {
+                    "payload": request_payload,
+                    "requestMethod": method,
+                    "requestUrl": request_url,
+                    "headers": dict(metadata),
+                }
+                _LOGGER.debug(
+                    f"Sending request for google.ai.generativelanguage_v1beta3.PermissionServiceClient.TransferOwnership",
+                    extra={
+                        "serviceName": "google.ai.generativelanguage.v1beta3.PermissionService",
+                        "rpcName": "TransferOwnership",
+                        "httpRequest": http_request,
+                        "metadata": http_request["headers"],
+                    },
+                )
+
+            # Send the request
+            response = PermissionServiceRestTransport._TransferOwnership._get_response(
+                self._host,
+                metadata,
+                query_params,
+                self._session,
+                timeout,
+                transcoded_request,
+                body,
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            # Return the response
+            resp = permission_service.TransferOwnershipResponse()
+            pb_resp = permission_service.TransferOwnershipResponse.pb(resp)
+
+            json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
+
+            resp = self._interceptor.post_transfer_ownership(resp)
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                logging.DEBUG
+            ):  # pragma: NO COVER
+                try:
+                    response_payload = (
+                        permission_service.TransferOwnershipResponse.to_json(response)
+                    )
+                except:
+                    response_payload = None
+                http_response = {
+                    "payload": response_payload,
+                    "headers": dict(response.headers),
+                    "status": response.status_code,
+                }
+                _LOGGER.debug(
+                    "Received response for google.ai.generativelanguage_v1beta3.PermissionServiceClient.transfer_ownership",
+                    extra={
+                        "serviceName": "google.ai.generativelanguage.v1beta3.PermissionService",
+                        "rpcName": "TransferOwnership",
+                        "metadata": http_response["headers"],
+                        "httpResponse": http_response,
+                    },
+                )
+            return resp
+
+    class _UpdatePermission(
+        _BasePermissionServiceRestTransport._BaseUpdatePermission,
+        PermissionServiceRestStub,
+    ):
+        def __hash__(self):
+            return hash("PermissionServiceRestTransport.UpdatePermission")
+
+        @staticmethod
+        def _get_response(
+            host,
+            metadata,
+            query_params,
+            session,
+            timeout,
+            transcoded_request,
+            body=None,
+        ):
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+            response = getattr(session, method)(
+                "{host}{uri}".format(host=host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params, strict=True),
+                data=body,
+            )
+            return response
+
+        def __call__(
+            self,
+            request: permission_service.UpdatePermissionRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
+        ) -> gag_permission.Permission:
+            r"""Call the update permission method over HTTP.
+
+            Args:
+                request (~.permission_service.UpdatePermissionRequest):
+                    The request object. Request to update the ``Permission``.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                    sent along with the request as metadata. Normally, each value must be of type `str`,
+                    but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                    be of type `bytes`.
+
+            Returns:
+                ~.gag_permission.Permission:
+                    Permission resource grants user,
+                group or the rest of the world access to
+                the PaLM API resource (e.g. a tuned
+                model, file).
+
+                A role is a collection of permitted
+                operations that allows users to perform
+                specific actions on PaLM API resources.
+                To make them available to users, groups,
+                or service accounts, you assign roles.
+                When you assign a role, you grant
+                permissions that the role contains.
+
+                There are three concentric roles. Each
+                role is a superset of the previous
+                role's permitted operations:
+
+                 - reader can use the resource (e.g.
+                  tuned model) for inference
+                 - writer has reader's permissions and
+                  additionally can edit and share
+                 - owner has writer's permissions and
+                  additionally can delete
+
+            """
+
+            http_options = (
+                _BasePermissionServiceRestTransport._BaseUpdatePermission._get_http_options()
+            )
+
+            request, metadata = self._interceptor.pre_update_permission(
+                request, metadata
+            )
+            transcoded_request = _BasePermissionServiceRestTransport._BaseUpdatePermission._get_transcoded_request(
+                http_options, request
+            )
+
+            body = _BasePermissionServiceRestTransport._BaseUpdatePermission._get_request_body_json(
+                transcoded_request
+            )
+
+            # Jsonify the query params
+            query_params = _BasePermissionServiceRestTransport._BaseUpdatePermission._get_query_params_json(
+                transcoded_request
+            )
+
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                logging.DEBUG
+            ):  # pragma: NO COVER
+                request_url = "{host}{uri}".format(
+                    host=self._host, uri=transcoded_request["uri"]
+                )
+                method = transcoded_request["method"]
+                try:
+                    request_payload = type(request).to_json(request)
+                except:
+                    request_payload = None
+                http_request = {
+                    "payload": request_payload,
+                    "requestMethod": method,
+                    "requestUrl": request_url,
+                    "headers": dict(metadata),
+                }
+                _LOGGER.debug(
+                    f"Sending request for google.ai.generativelanguage_v1beta3.PermissionServiceClient.UpdatePermission",
+                    extra={
+                        "serviceName": "google.ai.generativelanguage.v1beta3.PermissionService",
+                        "rpcName": "UpdatePermission",
+                        "httpRequest": http_request,
+                        "metadata": http_request["headers"],
+                    },
+                )
+
+            # Send the request
+            response = PermissionServiceRestTransport._UpdatePermission._get_response(
+                self._host,
+                metadata,
+                query_params,
+                self._session,
+                timeout,
+                transcoded_request,
+                body,
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            # Return the response
+            resp = gag_permission.Permission()
+            pb_resp = gag_permission.Permission.pb(resp)
+
+            json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
+
+            resp = self._interceptor.post_update_permission(resp)
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                logging.DEBUG
+            ):  # pragma: NO COVER
+                try:
+                    response_payload = gag_permission.Permission.to_json(response)
+                except:
+                    response_payload = None
+                http_response = {
+                    "payload": response_payload,
+                    "headers": dict(response.headers),
+                    "status": response.status_code,
+                }
+                _LOGGER.debug(
+                    "Received response for google.ai.generativelanguage_v1beta3.PermissionServiceClient.update_permission",
+                    extra={
+                        "serviceName": "google.ai.generativelanguage.v1beta3.PermissionService",
+                        "rpcName": "UpdatePermission",
+                        "metadata": http_response["headers"],
+                        "httpResponse": http_response,
+                    },
+                )
+            return resp
+
+    @property
+    def create_permission(
+        self,
+    ) -> Callable[
+        [permission_service.CreatePermissionRequest], gag_permission.Permission
+    ]:
+        # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
+        # In C++ this would require a dynamic_cast
+        return self._CreatePermission(self._session, self._host, self._interceptor)  # type: ignore
+
+    @property
+    def delete_permission(
+        self,
+    ) -> Callable[[permission_service.DeletePermissionRequest], empty_pb2.Empty]:
+        # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
+        # In C++ this would require a dynamic_cast
+        return self._DeletePermission(self._session, self._host, self._interceptor)  # type: ignore
+
+    @property
+    def get_permission(
+        self,
+    ) -> Callable[[permission_service.GetPermissionRequest], permission.Permission]:
+        # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
+        # In C++ this would require a dynamic_cast
+        return self._GetPermission(self._session, self._host, self._interceptor)  # type: ignore
+
+    @property
+    def list_permissions(
+        self,
+    ) -> Callable[
+        [permission_service.ListPermissionsRequest],
+        permission_service.ListPermissionsResponse,
+    ]:
+        # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
+        # In C++ this would require a dynamic_cast
+        return self._ListPermissions(self._session, self._host, self._interceptor)  # type: ignore
+
+    @property
+    def transfer_ownership(
+        self,
+    ) -> Callable[
+        [permission_service.TransferOwnershipRequest],
+        permission_service.TransferOwnershipResponse,
+    ]:
+        # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
+        # In C++ this would require a dynamic_cast
+        return self._TransferOwnership(self._session, self._host, self._interceptor)  # type: ignore
+
+    @property
+    def update_permission(
+        self,
+    ) -> Callable[
+        [permission_service.UpdatePermissionRequest], gag_permission.Permission
+    ]:
+        # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
+        # In C++ this would require a dynamic_cast
+        return self._UpdatePermission(self._session, self._host, self._interceptor)  # type: ignore
+
+    @property
+    def kind(self) -> str:
+        return "rest"
+
+    def close(self):
+        self._session.close()
+
+
+__all__ = ("PermissionServiceRestTransport",)

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/services/permission_service/transports/rest_base.py

@@ -0,0 +1,409 @@
+# -*- coding: utf-8 -*-
+# 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 json  # type: ignore
+import re
+from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union
+
+from google.api_core import gapic_v1, path_template
+from google.longrunning import operations_pb2  # type: ignore
+from google.protobuf import empty_pb2  # type: ignore
+from google.protobuf import json_format
+
+from google.ai.generativelanguage_v1beta3.types import permission as gag_permission
+from google.ai.generativelanguage_v1beta3.types import permission
+from google.ai.generativelanguage_v1beta3.types import permission_service
+
+from .base import DEFAULT_CLIENT_INFO, PermissionServiceTransport
+
+
+class _BasePermissionServiceRestTransport(PermissionServiceTransport):
+    """Base REST backend transport for PermissionService.
+
+    Note: This class is not meant to be used directly. Use its sync and
+    async sub-classes instead.
+
+    This class defines the same methods as the primary client, so the
+    primary client can load the underlying transport implementation
+    and call it.
+
+    It sends JSON representations of protocol buffers over HTTP/1.1
+    """
+
+    def __init__(
+        self,
+        *,
+        host: str = "generativelanguage.googleapis.com",
+        credentials: Optional[Any] = None,
+        client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
+        always_use_jwt_access: Optional[bool] = False,
+        url_scheme: str = "https",
+        api_audience: Optional[str] = None,
+    ) -> None:
+        """Instantiate the transport.
+        Args:
+            host (Optional[str]):
+                 The hostname to connect to (default: 'generativelanguage.googleapis.com').
+            credentials (Optional[Any]): The
+                authorization credentials to attach to requests. These
+                credentials identify the application to the service; if none
+                are specified, the client will attempt to ascertain the
+                credentials from the environment.
+            client_info (google.api_core.gapic_v1.client_info.ClientInfo):
+                The client info used to send a user-agent string along with
+                API requests. If ``None``, then default info will be used.
+                Generally, you only need to set this if you are developing
+                your own client library.
+            always_use_jwt_access (Optional[bool]): Whether self signed JWT should
+                be used for service account credentials.
+            url_scheme: the protocol scheme for the API endpoint.  Normally
+                "https", but for testing or local servers,
+                "http" can be specified.
+        """
+        # Run the base constructor
+        maybe_url_match = re.match("^(?P<scheme>http(?:s)?://)?(?P<host>.*)$", host)
+        if maybe_url_match is None:
+            raise ValueError(
+                f"Unexpected hostname structure: {host}"
+            )  # pragma: NO COVER
+
+        url_match_items = maybe_url_match.groupdict()
+
+        host = f"{url_scheme}://{host}" if not url_match_items["scheme"] else host
+
+        super().__init__(
+            host=host,
+            credentials=credentials,
+            client_info=client_info,
+            always_use_jwt_access=always_use_jwt_access,
+            api_audience=api_audience,
+        )
+
+    class _BaseCreatePermission:
+        def __hash__(self):  # pragma: NO COVER
+            return NotImplementedError("__hash__ must be implemented.")
+
+        __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+        @classmethod
+        def _get_unset_required_fields(cls, message_dict):
+            return {
+                k: v
+                for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+                if k not in message_dict
+            }
+
+        @staticmethod
+        def _get_http_options():
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1beta3/{parent=tunedModels/*}/permissions",
+                    "body": "permission",
+                },
+            ]
+            return http_options
+
+        @staticmethod
+        def _get_transcoded_request(http_options, request):
+            pb_request = permission_service.CreatePermissionRequest.pb(request)
+            transcoded_request = path_template.transcode(http_options, pb_request)
+            return transcoded_request
+
+        @staticmethod
+        def _get_request_body_json(transcoded_request):
+            # Jsonify the request body
+
+            body = json_format.MessageToJson(
+                transcoded_request["body"], use_integers_for_enums=True
+            )
+            return body
+
+        @staticmethod
+        def _get_query_params_json(transcoded_request):
+            query_params = json.loads(
+                json_format.MessageToJson(
+                    transcoded_request["query_params"],
+                    use_integers_for_enums=True,
+                )
+            )
+            query_params.update(
+                _BasePermissionServiceRestTransport._BaseCreatePermission._get_unset_required_fields(
+                    query_params
+                )
+            )
+
+            query_params["$alt"] = "json;enum-encoding=int"
+            return query_params
+
+    class _BaseDeletePermission:
+        def __hash__(self):  # pragma: NO COVER
+            return NotImplementedError("__hash__ must be implemented.")
+
+        __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+        @classmethod
+        def _get_unset_required_fields(cls, message_dict):
+            return {
+                k: v
+                for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+                if k not in message_dict
+            }
+
+        @staticmethod
+        def _get_http_options():
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "delete",
+                    "uri": "/v1beta3/{name=tunedModels/*/permissions/*}",
+                },
+            ]
+            return http_options
+
+        @staticmethod
+        def _get_transcoded_request(http_options, request):
+            pb_request = permission_service.DeletePermissionRequest.pb(request)
+            transcoded_request = path_template.transcode(http_options, pb_request)
+            return transcoded_request
+
+        @staticmethod
+        def _get_query_params_json(transcoded_request):
+            query_params = json.loads(
+                json_format.MessageToJson(
+                    transcoded_request["query_params"],
+                    use_integers_for_enums=True,
+                )
+            )
+            query_params.update(
+                _BasePermissionServiceRestTransport._BaseDeletePermission._get_unset_required_fields(
+                    query_params
+                )
+            )
+
+            query_params["$alt"] = "json;enum-encoding=int"
+            return query_params
+
+    class _BaseGetPermission:
+        def __hash__(self):  # pragma: NO COVER
+            return NotImplementedError("__hash__ must be implemented.")
+
+        __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+        @classmethod
+        def _get_unset_required_fields(cls, message_dict):
+            return {
+                k: v
+                for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+                if k not in message_dict
+            }
+
+        @staticmethod
+        def _get_http_options():
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "get",
+                    "uri": "/v1beta3/{name=tunedModels/*/permissions/*}",
+                },
+            ]
+            return http_options
+
+        @staticmethod
+        def _get_transcoded_request(http_options, request):
+            pb_request = permission_service.GetPermissionRequest.pb(request)
+            transcoded_request = path_template.transcode(http_options, pb_request)
+            return transcoded_request
+
+        @staticmethod
+        def _get_query_params_json(transcoded_request):
+            query_params = json.loads(
+                json_format.MessageToJson(
+                    transcoded_request["query_params"],
+                    use_integers_for_enums=True,
+                )
+            )
+            query_params.update(
+                _BasePermissionServiceRestTransport._BaseGetPermission._get_unset_required_fields(
+                    query_params
+                )
+            )
+
+            query_params["$alt"] = "json;enum-encoding=int"
+            return query_params
+
+    class _BaseListPermissions:
+        def __hash__(self):  # pragma: NO COVER
+            return NotImplementedError("__hash__ must be implemented.")
+
+        __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+        @classmethod
+        def _get_unset_required_fields(cls, message_dict):
+            return {
+                k: v
+                for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+                if k not in message_dict
+            }
+
+        @staticmethod
+        def _get_http_options():
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "get",
+                    "uri": "/v1beta3/{parent=tunedModels/*}/permissions",
+                },
+            ]
+            return http_options
+
+        @staticmethod
+        def _get_transcoded_request(http_options, request):
+            pb_request = permission_service.ListPermissionsRequest.pb(request)
+            transcoded_request = path_template.transcode(http_options, pb_request)
+            return transcoded_request
+
+        @staticmethod
+        def _get_query_params_json(transcoded_request):
+            query_params = json.loads(
+                json_format.MessageToJson(
+                    transcoded_request["query_params"],
+                    use_integers_for_enums=True,
+                )
+            )
+            query_params.update(
+                _BasePermissionServiceRestTransport._BaseListPermissions._get_unset_required_fields(
+                    query_params
+                )
+            )
+
+            query_params["$alt"] = "json;enum-encoding=int"
+            return query_params
+
+    class _BaseTransferOwnership:
+        def __hash__(self):  # pragma: NO COVER
+            return NotImplementedError("__hash__ must be implemented.")
+
+        __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {}
+
+        @classmethod
+        def _get_unset_required_fields(cls, message_dict):
+            return {
+                k: v
+                for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+                if k not in message_dict
+            }
+
+        @staticmethod
+        def _get_http_options():
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v1beta3/{name=tunedModels/*}:transferOwnership",
+                    "body": "*",
+                },
+            ]
+            return http_options
+
+        @staticmethod
+        def _get_transcoded_request(http_options, request):
+            pb_request = permission_service.TransferOwnershipRequest.pb(request)
+            transcoded_request = path_template.transcode(http_options, pb_request)
+            return transcoded_request
+
+        @staticmethod
+        def _get_request_body_json(transcoded_request):
+            # Jsonify the request body
+
+            body = json_format.MessageToJson(
+                transcoded_request["body"], use_integers_for_enums=True
+            )
+            return body
+
+        @staticmethod
+        def _get_query_params_json(transcoded_request):
+            query_params = json.loads(
+                json_format.MessageToJson(
+                    transcoded_request["query_params"],
+                    use_integers_for_enums=True,
+                )
+            )
+            query_params.update(
+                _BasePermissionServiceRestTransport._BaseTransferOwnership._get_unset_required_fields(
+                    query_params
+                )
+            )
+
+            query_params["$alt"] = "json;enum-encoding=int"
+            return query_params
+
+    class _BaseUpdatePermission:
+        def __hash__(self):  # pragma: NO COVER
+            return NotImplementedError("__hash__ must be implemented.")
+
+        __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {
+            "updateMask": {},
+        }
+
+        @classmethod
+        def _get_unset_required_fields(cls, message_dict):
+            return {
+                k: v
+                for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
+                if k not in message_dict
+            }
+
+        @staticmethod
+        def _get_http_options():
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "patch",
+                    "uri": "/v1beta3/{permission.name=tunedModels/*/permissions/*}",
+                    "body": "permission",
+                },
+            ]
+            return http_options
+
+        @staticmethod
+        def _get_transcoded_request(http_options, request):
+            pb_request = permission_service.UpdatePermissionRequest.pb(request)
+            transcoded_request = path_template.transcode(http_options, pb_request)
+            return transcoded_request
+
+        @staticmethod
+        def _get_request_body_json(transcoded_request):
+            # Jsonify the request body
+
+            body = json_format.MessageToJson(
+                transcoded_request["body"], use_integers_for_enums=True
+            )
+            return body
+
+        @staticmethod
+        def _get_query_params_json(transcoded_request):
+            query_params = json.loads(
+                json_format.MessageToJson(
+                    transcoded_request["query_params"],
+                    use_integers_for_enums=True,
+                )
+            )
+            query_params.update(
+                _BasePermissionServiceRestTransport._BaseUpdatePermission._get_unset_required_fields(
+                    query_params
+                )
+            )
+
+            query_params["$alt"] = "json;enum-encoding=int"
+            return query_params
+
+
+__all__ = ("_BasePermissionServiceRestTransport",)

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/types/__init__.py

@@ -0,0 +1,135 @@
+# -*- coding: utf-8 -*-
+# 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 .citation import CitationMetadata, CitationSource
+from .discuss_service import (
+    CountMessageTokensRequest,
+    CountMessageTokensResponse,
+    Example,
+    GenerateMessageRequest,
+    GenerateMessageResponse,
+    Message,
+    MessagePrompt,
+)
+from .model import Model
+from .model_service import (
+    CreateTunedModelMetadata,
+    CreateTunedModelRequest,
+    DeleteTunedModelRequest,
+    GetModelRequest,
+    GetTunedModelRequest,
+    ListModelsRequest,
+    ListModelsResponse,
+    ListTunedModelsRequest,
+    ListTunedModelsResponse,
+    UpdateTunedModelRequest,
+)
+from .permission import Permission
+from .permission_service import (
+    CreatePermissionRequest,
+    DeletePermissionRequest,
+    GetPermissionRequest,
+    ListPermissionsRequest,
+    ListPermissionsResponse,
+    TransferOwnershipRequest,
+    TransferOwnershipResponse,
+    UpdatePermissionRequest,
+)
+from .safety import (
+    ContentFilter,
+    HarmCategory,
+    SafetyFeedback,
+    SafetyRating,
+    SafetySetting,
+)
+from .text_service import (
+    BatchEmbedTextRequest,
+    BatchEmbedTextResponse,
+    CountTextTokensRequest,
+    CountTextTokensResponse,
+    Embedding,
+    EmbedTextRequest,
+    EmbedTextResponse,
+    GenerateTextRequest,
+    GenerateTextResponse,
+    TextCompletion,
+    TextPrompt,
+)
+from .tuned_model import (
+    Dataset,
+    Hyperparameters,
+    TunedModel,
+    TunedModelSource,
+    TuningExample,
+    TuningExamples,
+    TuningSnapshot,
+    TuningTask,
+)
+
+__all__ = (
+    "CitationMetadata",
+    "CitationSource",
+    "CountMessageTokensRequest",
+    "CountMessageTokensResponse",
+    "Example",
+    "GenerateMessageRequest",
+    "GenerateMessageResponse",
+    "Message",
+    "MessagePrompt",
+    "Model",
+    "CreateTunedModelMetadata",
+    "CreateTunedModelRequest",
+    "DeleteTunedModelRequest",
+    "GetModelRequest",
+    "GetTunedModelRequest",
+    "ListModelsRequest",
+    "ListModelsResponse",
+    "ListTunedModelsRequest",
+    "ListTunedModelsResponse",
+    "UpdateTunedModelRequest",
+    "Permission",
+    "CreatePermissionRequest",
+    "DeletePermissionRequest",
+    "GetPermissionRequest",
+    "ListPermissionsRequest",
+    "ListPermissionsResponse",
+    "TransferOwnershipRequest",
+    "TransferOwnershipResponse",
+    "UpdatePermissionRequest",
+    "ContentFilter",
+    "SafetyFeedback",
+    "SafetyRating",
+    "SafetySetting",
+    "HarmCategory",
+    "BatchEmbedTextRequest",
+    "BatchEmbedTextResponse",
+    "CountTextTokensRequest",
+    "CountTextTokensResponse",
+    "Embedding",
+    "EmbedTextRequest",
+    "EmbedTextResponse",
+    "GenerateTextRequest",
+    "GenerateTextResponse",
+    "TextCompletion",
+    "TextPrompt",
+    "Dataset",
+    "Hyperparameters",
+    "TunedModel",
+    "TunedModelSource",
+    "TuningExample",
+    "TuningExamples",
+    "TuningSnapshot",
+    "TuningTask",
+)

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/types/citation.py

@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*-
+# 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 __future__ import annotations
+
+from typing import MutableMapping, MutableSequence
+
+import proto  # type: ignore
+
+__protobuf__ = proto.module(
+    package="google.ai.generativelanguage.v1beta3",
+    manifest={
+        "CitationMetadata",
+        "CitationSource",
+    },
+)
+
+
+class CitationMetadata(proto.Message):
+    r"""A collection of source attributions for a piece of content.
+
+    Attributes:
+        citation_sources (MutableSequence[google.ai.generativelanguage_v1beta3.types.CitationSource]):
+            Citations to sources for a specific response.
+    """
+
+    citation_sources: MutableSequence["CitationSource"] = proto.RepeatedField(
+        proto.MESSAGE,
+        number=1,
+        message="CitationSource",
+    )
+
+
+class CitationSource(proto.Message):
+    r"""A citation to a source for a portion of a specific response.
+
+    .. _oneof: https://proto-plus-python.readthedocs.io/en/stable/fields.html#oneofs-mutually-exclusive-fields
+
+    Attributes:
+        start_index (int):
+            Optional. Start of segment of the response
+            that is attributed to this source.
+
+            Index indicates the start of the segment,
+            measured in bytes.
+
+            This field is a member of `oneof`_ ``_start_index``.
+        end_index (int):
+            Optional. End of the attributed segment,
+            exclusive.
+
+            This field is a member of `oneof`_ ``_end_index``.
+        uri (str):
+            Optional. URI that is attributed as a source
+            for a portion of the text.
+
+            This field is a member of `oneof`_ ``_uri``.
+        license_ (str):
+            Optional. License for the GitHub project that
+            is attributed as a source for segment.
+
+            License info is required for code citations.
+
+            This field is a member of `oneof`_ ``_license``.
+    """
+
+    start_index: int = proto.Field(
+        proto.INT32,
+        number=1,
+        optional=True,
+    )
+    end_index: int = proto.Field(
+        proto.INT32,
+        number=2,
+        optional=True,
+    )
+    uri: str = proto.Field(
+        proto.STRING,
+        number=3,
+        optional=True,
+    )
+    license_: str = proto.Field(
+        proto.STRING,
+        number=4,
+        optional=True,
+    )
+
+
+__all__ = tuple(sorted(__protobuf__.manifest))

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/types/discuss_service.py

@@ -0,0 +1,356 @@
+# -*- coding: utf-8 -*-
+# 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 __future__ import annotations
+
+from typing import MutableMapping, MutableSequence
+
+import proto  # type: ignore
+
+from google.ai.generativelanguage_v1beta3.types import citation, safety
+
+__protobuf__ = proto.module(
+    package="google.ai.generativelanguage.v1beta3",
+    manifest={
+        "GenerateMessageRequest",
+        "GenerateMessageResponse",
+        "Message",
+        "MessagePrompt",
+        "Example",
+        "CountMessageTokensRequest",
+        "CountMessageTokensResponse",
+    },
+)
+
+
+class GenerateMessageRequest(proto.Message):
+    r"""Request to generate a message response from the model.
+
+    .. _oneof: https://proto-plus-python.readthedocs.io/en/stable/fields.html#oneofs-mutually-exclusive-fields
+
+    Attributes:
+        model (str):
+            Required. The name of the model to use.
+
+            Format: ``name=models/{model}``.
+        prompt (google.ai.generativelanguage_v1beta3.types.MessagePrompt):
+            Required. The structured textual input given
+            to the model as a prompt.
+            Given a
+            prompt, the model will return what it predicts
+            is the next message in the discussion.
+        temperature (float):
+            Optional. Controls the randomness of the output.
+
+            Values can range over ``[0.0,1.0]``, inclusive. A value
+            closer to ``1.0`` will produce responses that are more
+            varied, while a value closer to ``0.0`` will typically
+            result in less surprising responses from the model.
+
+            This field is a member of `oneof`_ ``_temperature``.
+        candidate_count (int):
+            Optional. The number of generated response messages to
+            return.
+
+            This value must be between ``[1, 8]``, inclusive. If unset,
+            this will default to ``1``.
+
+            This field is a member of `oneof`_ ``_candidate_count``.
+        top_p (float):
+            Optional. The maximum cumulative probability of tokens to
+            consider when sampling.
+
+            The model uses combined Top-k and nucleus sampling.
+
+            Nucleus sampling considers the smallest set of tokens whose
+            probability sum is at least ``top_p``.
+
+            This field is a member of `oneof`_ ``_top_p``.
+        top_k (int):
+            Optional. The maximum number of tokens to consider when
+            sampling.
+
+            The model uses combined Top-k and nucleus sampling.
+
+            Top-k sampling considers the set of ``top_k`` most probable
+            tokens.
+
+            This field is a member of `oneof`_ ``_top_k``.
+    """
+
+    model: str = proto.Field(
+        proto.STRING,
+        number=1,
+    )
+    prompt: "MessagePrompt" = proto.Field(
+        proto.MESSAGE,
+        number=2,
+        message="MessagePrompt",
+    )
+    temperature: float = proto.Field(
+        proto.FLOAT,
+        number=3,
+        optional=True,
+    )
+    candidate_count: int = proto.Field(
+        proto.INT32,
+        number=4,
+        optional=True,
+    )
+    top_p: float = proto.Field(
+        proto.FLOAT,
+        number=5,
+        optional=True,
+    )
+    top_k: int = proto.Field(
+        proto.INT32,
+        number=6,
+        optional=True,
+    )
+
+
+class GenerateMessageResponse(proto.Message):
+    r"""The response from the model.
+
+    This includes candidate messages and
+    conversation history in the form of chronologically-ordered
+    messages.
+
+    Attributes:
+        candidates (MutableSequence[google.ai.generativelanguage_v1beta3.types.Message]):
+            Candidate response messages from the model.
+        messages (MutableSequence[google.ai.generativelanguage_v1beta3.types.Message]):
+            The conversation history used by the model.
+        filters (MutableSequence[google.ai.generativelanguage_v1beta3.types.ContentFilter]):
+            A set of content filtering metadata for the prompt and
+            response text.
+
+            This indicates which ``SafetyCategory``\ (s) blocked a
+            candidate from this response, the lowest ``HarmProbability``
+            that triggered a block, and the HarmThreshold setting for
+            that category.
+    """
+
+    candidates: MutableSequence["Message"] = proto.RepeatedField(
+        proto.MESSAGE,
+        number=1,
+        message="Message",
+    )
+    messages: MutableSequence["Message"] = proto.RepeatedField(
+        proto.MESSAGE,
+        number=2,
+        message="Message",
+    )
+    filters: MutableSequence[safety.ContentFilter] = proto.RepeatedField(
+        proto.MESSAGE,
+        number=3,
+        message=safety.ContentFilter,
+    )
+
+
+class Message(proto.Message):
+    r"""The base unit of structured text.
+
+    A ``Message`` includes an ``author`` and the ``content`` of the
+    ``Message``.
+
+    The ``author`` is used to tag messages when they are fed to the
+    model as text.
+
+
+    .. _oneof: https://proto-plus-python.readthedocs.io/en/stable/fields.html#oneofs-mutually-exclusive-fields
+
+    Attributes:
+        author (str):
+            Optional. The author of this Message.
+
+            This serves as a key for tagging
+            the content of this Message when it is fed to
+            the model as text.
+
+            The author can be any alphanumeric string.
+        content (str):
+            Required. The text content of the structured ``Message``.
+        citation_metadata (google.ai.generativelanguage_v1beta3.types.CitationMetadata):
+            Output only. Citation information for model-generated
+            ``content`` in this ``Message``.
+
+            If this ``Message`` was generated as output from the model,
+            this field may be populated with attribution information for
+            any text included in the ``content``. This field is used
+            only on output.
+
+            This field is a member of `oneof`_ ``_citation_metadata``.
+    """
+
+    author: str = proto.Field(
+        proto.STRING,
+        number=1,
+    )
+    content: str = proto.Field(
+        proto.STRING,
+        number=2,
+    )
+    citation_metadata: citation.CitationMetadata = proto.Field(
+        proto.MESSAGE,
+        number=3,
+        optional=True,
+        message=citation.CitationMetadata,
+    )
+
+
+class MessagePrompt(proto.Message):
+    r"""All of the structured input text passed to the model as a prompt.
+
+    A ``MessagePrompt`` contains a structured set of fields that provide
+    context for the conversation, examples of user input/model output
+    message pairs that prime the model to respond in different ways, and
+    the conversation history or list of messages representing the
+    alternating turns of the conversation between the user and the
+    model.
+
+    Attributes:
+        context (str):
+            Optional. Text that should be provided to the model first to
+            ground the response.
+
+            If not empty, this ``context`` will be given to the model
+            first before the ``examples`` and ``messages``. When using a
+            ``context`` be sure to provide it with every request to
+            maintain continuity.
+
+            This field can be a description of your prompt to the model
+            to help provide context and guide the responses. Examples:
+            "Translate the phrase from English to French." or "Given a
+            statement, classify the sentiment as happy, sad or neutral."
+
+            Anything included in this field will take precedence over
+            message history if the total input size exceeds the model's
+            ``input_token_limit`` and the input request is truncated.
+        examples (MutableSequence[google.ai.generativelanguage_v1beta3.types.Example]):
+            Optional. Examples of what the model should generate.
+
+            This includes both user input and the response that the
+            model should emulate.
+
+            These ``examples`` are treated identically to conversation
+            messages except that they take precedence over the history
+            in ``messages``: If the total input size exceeds the model's
+            ``input_token_limit`` the input will be truncated. Items
+            will be dropped from ``messages`` before ``examples``.
+        messages (MutableSequence[google.ai.generativelanguage_v1beta3.types.Message]):
+            Required. A snapshot of the recent conversation history
+            sorted chronologically.
+
+            Turns alternate between two authors.
+
+            If the total input size exceeds the model's
+            ``input_token_limit`` the input will be truncated: The
+            oldest items will be dropped from ``messages``.
+    """
+
+    context: str = proto.Field(
+        proto.STRING,
+        number=1,
+    )
+    examples: MutableSequence["Example"] = proto.RepeatedField(
+        proto.MESSAGE,
+        number=2,
+        message="Example",
+    )
+    messages: MutableSequence["Message"] = proto.RepeatedField(
+        proto.MESSAGE,
+        number=3,
+        message="Message",
+    )
+
+
+class Example(proto.Message):
+    r"""An input/output example used to instruct the Model.
+
+    It demonstrates how the model should respond or format its
+    response.
+
+    Attributes:
+        input (google.ai.generativelanguage_v1beta3.types.Message):
+            Required. An example of an input ``Message`` from the user.
+        output (google.ai.generativelanguage_v1beta3.types.Message):
+            Required. An example of what the model should
+            output given the input.
+    """
+
+    input: "Message" = proto.Field(
+        proto.MESSAGE,
+        number=1,
+        message="Message",
+    )
+    output: "Message" = proto.Field(
+        proto.MESSAGE,
+        number=2,
+        message="Message",
+    )
+
+
+class CountMessageTokensRequest(proto.Message):
+    r"""Counts the number of tokens in the ``prompt`` sent to a model.
+
+    Models may tokenize text differently, so each model may return a
+    different ``token_count``.
+
+    Attributes:
+        model (str):
+            Required. The model's resource name. This serves as an ID
+            for the Model to use.
+
+            This name should match a model name returned by the
+            ``ListModels`` method.
+
+            Format: ``models/{model}``
+        prompt (google.ai.generativelanguage_v1beta3.types.MessagePrompt):
+            Required. The prompt, whose token count is to
+            be returned.
+    """
+
+    model: str = proto.Field(
+        proto.STRING,
+        number=1,
+    )
+    prompt: "MessagePrompt" = proto.Field(
+        proto.MESSAGE,
+        number=2,
+        message="MessagePrompt",
+    )
+
+
+class CountMessageTokensResponse(proto.Message):
+    r"""A response from ``CountMessageTokens``.
+
+    It returns the model's ``token_count`` for the ``prompt``.
+
+    Attributes:
+        token_count (int):
+            The number of tokens that the ``model`` tokenizes the
+            ``prompt`` into.
+
+            Always non-negative.
+    """
+
+    token_count: int = proto.Field(
+        proto.INT32,
+        number=1,
+    )
+
+
+__all__ = tuple(sorted(__protobuf__.manifest))

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/types/model.py

@@ -0,0 +1,155 @@
+# -*- coding: utf-8 -*-
+# 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 __future__ import annotations
+
+from typing import MutableMapping, MutableSequence
+
+import proto  # type: ignore
+
+__protobuf__ = proto.module(
+    package="google.ai.generativelanguage.v1beta3",
+    manifest={
+        "Model",
+    },
+)
+
+
+class Model(proto.Message):
+    r"""Information about a Generative Language Model.
+
+    .. _oneof: https://proto-plus-python.readthedocs.io/en/stable/fields.html#oneofs-mutually-exclusive-fields
+
+    Attributes:
+        name (str):
+            Required. The resource name of the ``Model``.
+
+            Format: ``models/{model}`` with a ``{model}`` naming
+            convention of:
+
+            -  "{base_model_id}-{version}"
+
+            Examples:
+
+            -  ``models/chat-bison-001``
+        base_model_id (str):
+            Required. The name of the base model, pass this to the
+            generation request.
+
+            Examples:
+
+            -  ``chat-bison``
+        version (str):
+            Required. The version number of the model.
+
+            This represents the major version
+        display_name (str):
+            The human-readable name of the model. E.g.
+            "Chat Bison".
+            The name can be up to 128 characters long and
+            can consist of any UTF-8 characters.
+        description (str):
+            A short description of the model.
+        input_token_limit (int):
+            Maximum number of input tokens allowed for
+            this model.
+        output_token_limit (int):
+            Maximum number of output tokens available for
+            this model.
+        supported_generation_methods (MutableSequence[str]):
+            The model's supported generation methods.
+
+            The method names are defined as Pascal case strings, such as
+            ``generateMessage`` which correspond to API methods.
+        temperature (float):
+            Controls the randomness of the output.
+
+            Values can range over ``[0.0,1.0]``, inclusive. A value
+            closer to ``1.0`` will produce responses that are more
+            varied, while a value closer to ``0.0`` will typically
+            result in less surprising responses from the model. This
+            value specifies default to be used by the backend while
+            making the call to the model.
+
+            This field is a member of `oneof`_ ``_temperature``.
+        top_p (float):
+            For Nucleus sampling.
+
+            Nucleus sampling considers the smallest set of tokens whose
+            probability sum is at least ``top_p``. This value specifies
+            default to be used by the backend while making the call to
+            the model.
+
+            This field is a member of `oneof`_ ``_top_p``.
+        top_k (int):
+            For Top-k sampling.
+
+            Top-k sampling considers the set of ``top_k`` most probable
+            tokens. This value specifies default to be used by the
+            backend while making the call to the model.
+
+            This field is a member of `oneof`_ ``_top_k``.
+    """
+
+    name: str = proto.Field(
+        proto.STRING,
+        number=1,
+    )
+    base_model_id: str = proto.Field(
+        proto.STRING,
+        number=2,
+    )
+    version: str = proto.Field(
+        proto.STRING,
+        number=3,
+    )
+    display_name: str = proto.Field(
+        proto.STRING,
+        number=4,
+    )
+    description: str = proto.Field(
+        proto.STRING,
+        number=5,
+    )
+    input_token_limit: int = proto.Field(
+        proto.INT32,
+        number=6,
+    )
+    output_token_limit: int = proto.Field(
+        proto.INT32,
+        number=7,
+    )
+    supported_generation_methods: MutableSequence[str] = proto.RepeatedField(
+        proto.STRING,
+        number=8,
+    )
+    temperature: float = proto.Field(
+        proto.FLOAT,
+        number=9,
+        optional=True,
+    )
+    top_p: float = proto.Field(
+        proto.FLOAT,
+        number=10,
+        optional=True,
+    )
+    top_k: int = proto.Field(
+        proto.INT32,
+        number=11,
+        optional=True,
+    )
+
+
+__all__ = tuple(sorted(__protobuf__.manifest))

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/types/model_service.py

@@ -0,0 +1,309 @@
+# -*- coding: utf-8 -*-
+# 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 __future__ import annotations
+
+from typing import MutableMapping, MutableSequence
+
+from google.protobuf import field_mask_pb2  # type: ignore
+import proto  # type: ignore
+
+from google.ai.generativelanguage_v1beta3.types import tuned_model as gag_tuned_model
+from google.ai.generativelanguage_v1beta3.types import model
+
+__protobuf__ = proto.module(
+    package="google.ai.generativelanguage.v1beta3",
+    manifest={
+        "GetModelRequest",
+        "ListModelsRequest",
+        "ListModelsResponse",
+        "GetTunedModelRequest",
+        "ListTunedModelsRequest",
+        "ListTunedModelsResponse",
+        "CreateTunedModelRequest",
+        "CreateTunedModelMetadata",
+        "UpdateTunedModelRequest",
+        "DeleteTunedModelRequest",
+    },
+)
+
+
+class GetModelRequest(proto.Message):
+    r"""Request for getting information about a specific Model.
+
+    Attributes:
+        name (str):
+            Required. The resource name of the model.
+
+            This name should match a model name returned by the
+            ``ListModels`` method.
+
+            Format: ``models/{model}``
+    """
+
+    name: str = proto.Field(
+        proto.STRING,
+        number=1,
+    )
+
+
+class ListModelsRequest(proto.Message):
+    r"""Request for listing all Models.
+
+    Attributes:
+        page_size (int):
+            The maximum number of ``Models`` to return (per page).
+
+            The service may return fewer models. If unspecified, at most
+            50 models will be returned per page. This method returns at
+            most 1000 models per page, even if you pass a larger
+            page_size.
+        page_token (str):
+            A page token, received from a previous ``ListModels`` call.
+
+            Provide the ``page_token`` returned by one request as an
+            argument to the next request to retrieve the next page.
+
+            When paginating, all other parameters provided to
+            ``ListModels`` must match the call that provided the page
+            token.
+    """
+
+    page_size: int = proto.Field(
+        proto.INT32,
+        number=2,
+    )
+    page_token: str = proto.Field(
+        proto.STRING,
+        number=3,
+    )
+
+
+class ListModelsResponse(proto.Message):
+    r"""Response from ``ListModel`` containing a paginated list of Models.
+
+    Attributes:
+        models (MutableSequence[google.ai.generativelanguage_v1beta3.types.Model]):
+            The returned Models.
+        next_page_token (str):
+            A token, which can be sent as ``page_token`` to retrieve the
+            next page.
+
+            If this field is omitted, there are no more pages.
+    """
+
+    @property
+    def raw_page(self):
+        return self
+
+    models: MutableSequence[model.Model] = proto.RepeatedField(
+        proto.MESSAGE,
+        number=1,
+        message=model.Model,
+    )
+    next_page_token: str = proto.Field(
+        proto.STRING,
+        number=2,
+    )
+
+
+class GetTunedModelRequest(proto.Message):
+    r"""Request for getting information about a specific Model.
+
+    Attributes:
+        name (str):
+            Required. The resource name of the model.
+
+            Format: ``tunedModels/my-model-id``
+    """
+
+    name: str = proto.Field(
+        proto.STRING,
+        number=1,
+    )
+
+
+class ListTunedModelsRequest(proto.Message):
+    r"""Request for listing TunedModels.
+
+    Attributes:
+        page_size (int):
+            Optional. The maximum number of ``TunedModels`` to return
+            (per page). The service may return fewer tuned models.
+
+            If unspecified, at most 10 tuned models will be returned.
+            This method returns at most 1000 models per page, even if
+            you pass a larger page_size.
+        page_token (str):
+            Optional. A page token, received from a previous
+            ``ListTunedModels`` call.
+
+            Provide the ``page_token`` returned by one request as an
+            argument to the next request to retrieve the next page.
+
+            When paginating, all other parameters provided to
+            ``ListTunedModels`` must match the call that provided the
+            page token.
+    """
+
+    page_size: int = proto.Field(
+        proto.INT32,
+        number=1,
+    )
+    page_token: str = proto.Field(
+        proto.STRING,
+        number=2,
+    )
+
+
+class ListTunedModelsResponse(proto.Message):
+    r"""Response from ``ListTunedModels`` containing a paginated list of
+    Models.
+
+    Attributes:
+        tuned_models (MutableSequence[google.ai.generativelanguage_v1beta3.types.TunedModel]):
+            The returned Models.
+        next_page_token (str):
+            A token, which can be sent as ``page_token`` to retrieve the
+            next page.
+
+            If this field is omitted, there are no more pages.
+    """
+
+    @property
+    def raw_page(self):
+        return self
+
+    tuned_models: MutableSequence[gag_tuned_model.TunedModel] = proto.RepeatedField(
+        proto.MESSAGE,
+        number=1,
+        message=gag_tuned_model.TunedModel,
+    )
+    next_page_token: str = proto.Field(
+        proto.STRING,
+        number=2,
+    )
+
+
+class CreateTunedModelRequest(proto.Message):
+    r"""Request to create a TunedModel.
+
+    .. _oneof: https://proto-plus-python.readthedocs.io/en/stable/fields.html#oneofs-mutually-exclusive-fields
+
+    Attributes:
+        tuned_model_id (str):
+            Optional. The unique id for the tuned model if specified.
+            This value should be up to 40 characters, the first
+            character must be a letter, the last could be a letter or a
+            number. The id must match the regular expression:
+            `a-z <[a-z0-9-]{0,38}[a-z0-9]>`__?.
+
+            This field is a member of `oneof`_ ``_tuned_model_id``.
+        tuned_model (google.ai.generativelanguage_v1beta3.types.TunedModel):
+            Required. The tuned model to create.
+    """
+
+    tuned_model_id: str = proto.Field(
+        proto.STRING,
+        number=1,
+        optional=True,
+    )
+    tuned_model: gag_tuned_model.TunedModel = proto.Field(
+        proto.MESSAGE,
+        number=2,
+        message=gag_tuned_model.TunedModel,
+    )
+
+
+class CreateTunedModelMetadata(proto.Message):
+    r"""Metadata about the state and progress of creating a tuned
+    model returned from the long-running operation
+
+    Attributes:
+        tuned_model (str):
+            Name of the tuned model associated with the
+            tuning operation.
+        total_steps (int):
+            The total number of tuning steps.
+        completed_steps (int):
+            The number of steps completed.
+        completed_percent (float):
+            The completed percentage for the tuning
+            operation.
+        snapshots (MutableSequence[google.ai.generativelanguage_v1beta3.types.TuningSnapshot]):
+            Metrics collected during tuning.
+    """
+
+    tuned_model: str = proto.Field(
+        proto.STRING,
+        number=5,
+    )
+    total_steps: int = proto.Field(
+        proto.INT32,
+        number=1,
+    )
+    completed_steps: int = proto.Field(
+        proto.INT32,
+        number=2,
+    )
+    completed_percent: float = proto.Field(
+        proto.FLOAT,
+        number=3,
+    )
+    snapshots: MutableSequence[gag_tuned_model.TuningSnapshot] = proto.RepeatedField(
+        proto.MESSAGE,
+        number=4,
+        message=gag_tuned_model.TuningSnapshot,
+    )
+
+
+class UpdateTunedModelRequest(proto.Message):
+    r"""Request to update a TunedModel.
+
+    Attributes:
+        tuned_model (google.ai.generativelanguage_v1beta3.types.TunedModel):
+            Required. The tuned model to update.
+        update_mask (google.protobuf.field_mask_pb2.FieldMask):
+            Required. The list of fields to update.
+    """
+
+    tuned_model: gag_tuned_model.TunedModel = proto.Field(
+        proto.MESSAGE,
+        number=1,
+        message=gag_tuned_model.TunedModel,
+    )
+    update_mask: field_mask_pb2.FieldMask = proto.Field(
+        proto.MESSAGE,
+        number=2,
+        message=field_mask_pb2.FieldMask,
+    )
+
+
+class DeleteTunedModelRequest(proto.Message):
+    r"""Request to delete a TunedModel.
+
+    Attributes:
+        name (str):
+            Required. The resource name of the model. Format:
+            ``tunedModels/my-model-id``
+    """
+
+    name: str = proto.Field(
+        proto.STRING,
+        number=1,
+    )
+
+
+__all__ = tuple(sorted(__protobuf__.manifest))

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/types/permission.py

@@ -0,0 +1,140 @@
+# -*- coding: utf-8 -*-
+# 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 __future__ import annotations
+
+from typing import MutableMapping, MutableSequence
+
+import proto  # type: ignore
+
+__protobuf__ = proto.module(
+    package="google.ai.generativelanguage.v1beta3",
+    manifest={
+        "Permission",
+    },
+)
+
+
+class Permission(proto.Message):
+    r"""Permission resource grants user, group or the rest of the
+    world access to the PaLM API resource (e.g. a tuned model,
+    file).
+
+    A role is a collection of permitted operations that allows users
+    to perform specific actions on PaLM API resources. To make them
+    available to users, groups, or service accounts, you assign
+    roles. When you assign a role, you grant permissions that the
+    role contains.
+
+    There are three concentric roles. Each role is a superset of the
+    previous role's permitted operations:
+
+    - reader can use the resource (e.g. tuned model) for inference
+    - writer has reader's permissions and additionally can edit and
+      share
+    - owner has writer's permissions and additionally can delete
+
+
+    .. _oneof: https://proto-plus-python.readthedocs.io/en/stable/fields.html#oneofs-mutually-exclusive-fields
+
+    Attributes:
+        name (str):
+            Output only. The permission name. A unique name will be
+            generated on create. Example:
+            tunedModels/{tuned_model}permssions/{permission} Output
+            only.
+        grantee_type (google.ai.generativelanguage_v1beta3.types.Permission.GranteeType):
+            Required. Immutable. The type of the grantee.
+
+            This field is a member of `oneof`_ ``_grantee_type``.
+        email_address (str):
+            Optional. Immutable. The email address of the
+            user of group which this permission refers.
+            Field is not set when permission's grantee type
+            is EVERYONE.
+
+            This field is a member of `oneof`_ ``_email_address``.
+        role (google.ai.generativelanguage_v1beta3.types.Permission.Role):
+            Required. The role granted by this
+            permission.
+
+            This field is a member of `oneof`_ ``_role``.
+    """
+
+    class GranteeType(proto.Enum):
+        r"""Defines types of the grantee of this permission.
+
+        Values:
+            GRANTEE_TYPE_UNSPECIFIED (0):
+                The default value. This value is unused.
+            USER (1):
+                Represents a user. When set, you must provide email_address
+                for the user.
+            GROUP (2):
+                Represents a group. When set, you must provide email_address
+                for the group.
+            EVERYONE (3):
+                Represents access to everyone. No extra
+                information is required.
+        """
+        GRANTEE_TYPE_UNSPECIFIED = 0
+        USER = 1
+        GROUP = 2
+        EVERYONE = 3
+
+    class Role(proto.Enum):
+        r"""Defines the role granted by this permission.
+
+        Values:
+            ROLE_UNSPECIFIED (0):
+                The default value. This value is unused.
+            OWNER (1):
+                Owner can use, update, share and delete the
+                resource.
+            WRITER (2):
+                Writer can use, update and share the
+                resource.
+            READER (3):
+                Reader can use the resource.
+        """
+        ROLE_UNSPECIFIED = 0
+        OWNER = 1
+        WRITER = 2
+        READER = 3
+
+    name: str = proto.Field(
+        proto.STRING,
+        number=1,
+    )
+    grantee_type: GranteeType = proto.Field(
+        proto.ENUM,
+        number=2,
+        optional=True,
+        enum=GranteeType,
+    )
+    email_address: str = proto.Field(
+        proto.STRING,
+        number=3,
+        optional=True,
+    )
+    role: Role = proto.Field(
+        proto.ENUM,
+        number=4,
+        optional=True,
+        enum=Role,
+    )
+
+
+__all__ = tuple(sorted(__protobuf__.manifest))

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/types/permission_service.py

@@ -0,0 +1,218 @@
+# -*- coding: utf-8 -*-
+# 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 __future__ import annotations
+
+from typing import MutableMapping, MutableSequence
+
+from google.protobuf import field_mask_pb2  # type: ignore
+import proto  # type: ignore
+
+from google.ai.generativelanguage_v1beta3.types import permission as gag_permission
+
+__protobuf__ = proto.module(
+    package="google.ai.generativelanguage.v1beta3",
+    manifest={
+        "CreatePermissionRequest",
+        "GetPermissionRequest",
+        "ListPermissionsRequest",
+        "ListPermissionsResponse",
+        "UpdatePermissionRequest",
+        "DeletePermissionRequest",
+        "TransferOwnershipRequest",
+        "TransferOwnershipResponse",
+    },
+)
+
+
+class CreatePermissionRequest(proto.Message):
+    r"""Request to create a ``Permission``.
+
+    Attributes:
+        parent (str):
+            Required. The parent resource of the ``Permission``. Format:
+            tunedModels/{tuned_model}
+        permission (google.ai.generativelanguage_v1beta3.types.Permission):
+            Required. The permission to create.
+    """
+
+    parent: str = proto.Field(
+        proto.STRING,
+        number=1,
+    )
+    permission: gag_permission.Permission = proto.Field(
+        proto.MESSAGE,
+        number=2,
+        message=gag_permission.Permission,
+    )
+
+
+class GetPermissionRequest(proto.Message):
+    r"""Request for getting information about a specific ``Permission``.
+
+    Attributes:
+        name (str):
+            Required. The resource name of the permission.
+
+            Format:
+            ``tunedModels/{tuned_model}permissions/{permission}``
+    """
+
+    name: str = proto.Field(
+        proto.STRING,
+        number=1,
+    )
+
+
+class ListPermissionsRequest(proto.Message):
+    r"""Request for listing permissions.
+
+    Attributes:
+        parent (str):
+            Required. The parent resource of the permissions. Format:
+            tunedModels/{tuned_model}
+        page_size (int):
+            Optional. The maximum number of ``Permission``\ s to return
+            (per page). The service may return fewer permissions.
+
+            If unspecified, at most 10 permissions will be returned.
+            This method returns at most 1000 permissions per page, even
+            if you pass larger page_size.
+        page_token (str):
+            Optional. A page token, received from a previous
+            ``ListPermissions`` call.
+
+            Provide the ``page_token`` returned by one request as an
+            argument to the next request to retrieve the next page.
+
+            When paginating, all other parameters provided to
+            ``ListPermissions`` must match the call that provided the
+            page token.
+    """
+
+    parent: str = proto.Field(
+        proto.STRING,
+        number=1,
+    )
+    page_size: int = proto.Field(
+        proto.INT32,
+        number=2,
+    )
+    page_token: str = proto.Field(
+        proto.STRING,
+        number=3,
+    )
+
+
+class ListPermissionsResponse(proto.Message):
+    r"""Response from ``ListPermissions`` containing a paginated list of
+    permissions.
+
+    Attributes:
+        permissions (MutableSequence[google.ai.generativelanguage_v1beta3.types.Permission]):
+            Returned permissions.
+        next_page_token (str):
+            A token, which can be sent as ``page_token`` to retrieve the
+            next page.
+
+            If this field is omitted, there are no more pages.
+    """
+
+    @property
+    def raw_page(self):
+        return self
+
+    permissions: MutableSequence[gag_permission.Permission] = proto.RepeatedField(
+        proto.MESSAGE,
+        number=1,
+        message=gag_permission.Permission,
+    )
+    next_page_token: str = proto.Field(
+        proto.STRING,
+        number=2,
+    )
+
+
+class UpdatePermissionRequest(proto.Message):
+    r"""Request to update the ``Permission``.
+
+    Attributes:
+        permission (google.ai.generativelanguage_v1beta3.types.Permission):
+            Required. The permission to update.
+
+            The permission's ``name`` field is used to identify the
+            permission to update.
+        update_mask (google.protobuf.field_mask_pb2.FieldMask):
+            Required. The list of fields to update. Accepted ones:
+
+            -  role (``Permission.role`` field)
+    """
+
+    permission: gag_permission.Permission = proto.Field(
+        proto.MESSAGE,
+        number=1,
+        message=gag_permission.Permission,
+    )
+    update_mask: field_mask_pb2.FieldMask = proto.Field(
+        proto.MESSAGE,
+        number=2,
+        message=field_mask_pb2.FieldMask,
+    )
+
+
+class DeletePermissionRequest(proto.Message):
+    r"""Request to delete the ``Permission``.
+
+    Attributes:
+        name (str):
+            Required. The resource name of the permission. Format:
+            ``tunedModels/{tuned_model}/permissions/{permission}``
+    """
+
+    name: str = proto.Field(
+        proto.STRING,
+        number=1,
+    )
+
+
+class TransferOwnershipRequest(proto.Message):
+    r"""Request to transfer the ownership of the tuned model.
+
+    Attributes:
+        name (str):
+            Required. The resource name of the tuned model to transfer
+            ownership .
+
+            Format: ``tunedModels/my-model-id``
+        email_address (str):
+            Required. The email address of the user to
+            whom the tuned model is being transferred to.
+    """
+
+    name: str = proto.Field(
+        proto.STRING,
+        number=1,
+    )
+    email_address: str = proto.Field(
+        proto.STRING,
+        number=2,
+    )
+
+
+class TransferOwnershipResponse(proto.Message):
+    r"""Response from ``TransferOwnership``."""
+
+
+__all__ = tuple(sorted(__protobuf__.manifest))

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/types/safety.py

@@ -0,0 +1,252 @@
+# -*- coding: utf-8 -*-
+# 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 __future__ import annotations
+
+from typing import MutableMapping, MutableSequence
+
+import proto  # type: ignore
+
+__protobuf__ = proto.module(
+    package="google.ai.generativelanguage.v1beta3",
+    manifest={
+        "HarmCategory",
+        "ContentFilter",
+        "SafetyFeedback",
+        "SafetyRating",
+        "SafetySetting",
+    },
+)
+
+
+class HarmCategory(proto.Enum):
+    r"""The category of a rating.
+
+    These categories cover various kinds of harms that developers
+    may wish to adjust.
+
+    Values:
+        HARM_CATEGORY_UNSPECIFIED (0):
+            Category is unspecified.
+        HARM_CATEGORY_DEROGATORY (1):
+            Negative or harmful comments targeting
+            identity and/or protected attribute.
+        HARM_CATEGORY_TOXICITY (2):
+            Content that is rude, disrepspectful, or
+            profane.
+        HARM_CATEGORY_VIOLENCE (3):
+            Describes scenarios depictng violence against
+            an individual or group, or general descriptions
+            of gore.
+        HARM_CATEGORY_SEXUAL (4):
+            Contains references to sexual acts or other
+            lewd content.
+        HARM_CATEGORY_MEDICAL (5):
+            Promotes unchecked medical advice.
+        HARM_CATEGORY_DANGEROUS (6):
+            Dangerous content that promotes, facilitates,
+            or encourages harmful acts.
+    """
+    HARM_CATEGORY_UNSPECIFIED = 0
+    HARM_CATEGORY_DEROGATORY = 1
+    HARM_CATEGORY_TOXICITY = 2
+    HARM_CATEGORY_VIOLENCE = 3
+    HARM_CATEGORY_SEXUAL = 4
+    HARM_CATEGORY_MEDICAL = 5
+    HARM_CATEGORY_DANGEROUS = 6
+
+
+class ContentFilter(proto.Message):
+    r"""Content filtering metadata associated with processing a
+    single request.
+    ContentFilter contains a reason and an optional supporting
+    string. The reason may be unspecified.
+
+
+    .. _oneof: https://proto-plus-python.readthedocs.io/en/stable/fields.html#oneofs-mutually-exclusive-fields
+
+    Attributes:
+        reason (google.ai.generativelanguage_v1beta3.types.ContentFilter.BlockedReason):
+            The reason content was blocked during request
+            processing.
+        message (str):
+            A string that describes the filtering
+            behavior in more detail.
+
+            This field is a member of `oneof`_ ``_message``.
+    """
+
+    class BlockedReason(proto.Enum):
+        r"""A list of reasons why content may have been blocked.
+
+        Values:
+            BLOCKED_REASON_UNSPECIFIED (0):
+                A blocked reason was not specified.
+            SAFETY (1):
+                Content was blocked by safety settings.
+            OTHER (2):
+                Content was blocked, but the reason is
+                uncategorized.
+        """
+        BLOCKED_REASON_UNSPECIFIED = 0
+        SAFETY = 1
+        OTHER = 2
+
+    reason: BlockedReason = proto.Field(
+        proto.ENUM,
+        number=1,
+        enum=BlockedReason,
+    )
+    message: str = proto.Field(
+        proto.STRING,
+        number=2,
+        optional=True,
+    )
+
+
+class SafetyFeedback(proto.Message):
+    r"""Safety feedback for an entire request.
+
+    This field is populated if content in the input and/or response
+    is blocked due to safety settings. SafetyFeedback may not exist
+    for every HarmCategory. Each SafetyFeedback will return the
+    safety settings used by the request as well as the lowest
+    HarmProbability that should be allowed in order to return a
+    result.
+
+    Attributes:
+        rating (google.ai.generativelanguage_v1beta3.types.SafetyRating):
+            Safety rating evaluated from content.
+        setting (google.ai.generativelanguage_v1beta3.types.SafetySetting):
+            Safety settings applied to the request.
+    """
+
+    rating: "SafetyRating" = proto.Field(
+        proto.MESSAGE,
+        number=1,
+        message="SafetyRating",
+    )
+    setting: "SafetySetting" = proto.Field(
+        proto.MESSAGE,
+        number=2,
+        message="SafetySetting",
+    )
+
+
+class SafetyRating(proto.Message):
+    r"""Safety rating for a piece of content.
+
+    The safety rating contains the category of harm and the harm
+    probability level in that category for a piece of content.
+    Content is classified for safety across a number of harm
+    categories and the probability of the harm classification is
+    included here.
+
+    Attributes:
+        category (google.ai.generativelanguage_v1beta3.types.HarmCategory):
+            Required. The category for this rating.
+        probability (google.ai.generativelanguage_v1beta3.types.SafetyRating.HarmProbability):
+            Required. The probability of harm for this
+            content.
+    """
+
+    class HarmProbability(proto.Enum):
+        r"""The probability that a piece of content is harmful.
+
+        The classification system gives the probability of the content
+        being unsafe. This does not indicate the severity of harm for a
+        piece of content.
+
+        Values:
+            HARM_PROBABILITY_UNSPECIFIED (0):
+                Probability is unspecified.
+            NEGLIGIBLE (1):
+                Content has a negligible chance of being
+                unsafe.
+            LOW (2):
+                Content has a low chance of being unsafe.
+            MEDIUM (3):
+                Content has a medium chance of being unsafe.
+            HIGH (4):
+                Content has a high chance of being unsafe.
+        """
+        HARM_PROBABILITY_UNSPECIFIED = 0
+        NEGLIGIBLE = 1
+        LOW = 2
+        MEDIUM = 3
+        HIGH = 4
+
+    category: "HarmCategory" = proto.Field(
+        proto.ENUM,
+        number=3,
+        enum="HarmCategory",
+    )
+    probability: HarmProbability = proto.Field(
+        proto.ENUM,
+        number=4,
+        enum=HarmProbability,
+    )
+
+
+class SafetySetting(proto.Message):
+    r"""Safety setting, affecting the safety-blocking behavior.
+
+    Passing a safety setting for a category changes the allowed
+    proability that content is blocked.
+
+    Attributes:
+        category (google.ai.generativelanguage_v1beta3.types.HarmCategory):
+            Required. The category for this setting.
+        threshold (google.ai.generativelanguage_v1beta3.types.SafetySetting.HarmBlockThreshold):
+            Required. Controls the probability threshold
+            at which harm is blocked.
+    """
+
+    class HarmBlockThreshold(proto.Enum):
+        r"""Block at and beyond a specified harm probability.
+
+        Values:
+            HARM_BLOCK_THRESHOLD_UNSPECIFIED (0):
+                Threshold is unspecified.
+            BLOCK_LOW_AND_ABOVE (1):
+                Content with NEGLIGIBLE will be allowed.
+            BLOCK_MEDIUM_AND_ABOVE (2):
+                Content with NEGLIGIBLE and LOW will be
+                allowed.
+            BLOCK_ONLY_HIGH (3):
+                Content with NEGLIGIBLE, LOW, and MEDIUM will
+                be allowed.
+            BLOCK_NONE (4):
+                All content will be allowed.
+        """
+        HARM_BLOCK_THRESHOLD_UNSPECIFIED = 0
+        BLOCK_LOW_AND_ABOVE = 1
+        BLOCK_MEDIUM_AND_ABOVE = 2
+        BLOCK_ONLY_HIGH = 3
+        BLOCK_NONE = 4
+
+    category: "HarmCategory" = proto.Field(
+        proto.ENUM,
+        number=3,
+        enum="HarmCategory",
+    )
+    threshold: HarmBlockThreshold = proto.Field(
+        proto.ENUM,
+        number=4,
+        enum=HarmBlockThreshold,
+    )
+
+
+__all__ = tuple(sorted(__protobuf__.manifest))

.venv/lib/python3.11/site-packages/google/ai/generativelanguage_v1beta3/types/text_service.py

@@ -0,0 +1,429 @@
+# -*- coding: utf-8 -*-
+# 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 __future__ import annotations
+
+from typing import MutableMapping, MutableSequence
+
+import proto  # type: ignore
+
+from google.ai.generativelanguage_v1beta3.types import citation, safety
+
+__protobuf__ = proto.module(
+    package="google.ai.generativelanguage.v1beta3",
+    manifest={
+        "GenerateTextRequest",
+        "GenerateTextResponse",
+        "TextPrompt",
+        "TextCompletion",
+        "EmbedTextRequest",
+        "EmbedTextResponse",
+        "BatchEmbedTextRequest",
+        "BatchEmbedTextResponse",
+        "Embedding",
+        "CountTextTokensRequest",
+        "CountTextTokensResponse",
+    },
+)
+
+
+class GenerateTextRequest(proto.Message):
+    r"""Request to generate a text completion response from the
+    model.
+
+
+    .. _oneof: https://proto-plus-python.readthedocs.io/en/stable/fields.html#oneofs-mutually-exclusive-fields
+
+    Attributes:
+        model (str):
+            Required. The name of the ``Model`` or ``TunedModel`` to use
+            for generating the completion. Examples:
+            models/text-bison-001 tunedModels/sentence-translator-u3b7m
+        prompt (google.ai.generativelanguage_v1beta3.types.TextPrompt):
+            Required. The free-form input text given to
+            the model as a prompt.
+            Given a prompt, the model will generate a
+            TextCompletion response it predicts as the
+            completion of the input text.
+        temperature (float):
+            Optional. Controls the randomness of the output. Note: The
+            default value varies by model, see the ``Model.temperature``
+            attribute of the ``Model`` returned the ``getModel``
+            function.
+
+            Values can range from [0.0,1.0], inclusive. A value closer
+            to 1.0 will produce responses that are more varied and
+            creative, while a value closer to 0.0 will typically result
+            in more straightforward responses from the model.
+
+            This field is a member of `oneof`_ ``_temperature``.
+        candidate_count (int):
+            Optional. Number of generated responses to return.
+
+            This value must be between [1, 8], inclusive. If unset, this
+            will default to 1.
+
+            This field is a member of `oneof`_ ``_candidate_count``.
+        max_output_tokens (int):
+            Optional. The maximum number of tokens to include in a
+            candidate.
+
+            If unset, this will default to output_token_limit specified
+            in the ``Model`` specification.
+
+            This field is a member of `oneof`_ ``_max_output_tokens``.
+        top_p (float):
+            Optional. The maximum cumulative probability of tokens to
+            consider when sampling.
+
+            The model uses combined Top-k and nucleus sampling.
+
+            Tokens are sorted based on their assigned probabilities so
+            that only the most likely tokens are considered. Top-k
+            sampling directly limits the maximum number of tokens to
+            consider, while Nucleus sampling limits number of tokens
+            based on the cumulative probability.
+
+            Note: The default value varies by model, see the
+            ``Model.top_p`` attribute of the ``Model`` returned the
+            ``getModel`` function.
+
+            This field is a member of `oneof`_ ``_top_p``.
+        top_k (int):
+            Optional. The maximum number of tokens to consider when
+            sampling.
+
+            The model uses combined Top-k and nucleus sampling.
+
+            Top-k sampling considers the set of ``top_k`` most probable
+            tokens. Defaults to 40.
+
+            Note: The default value varies by model, see the
+            ``Model.top_k`` attribute of the ``Model`` returned the
+            ``getModel`` function.
+
+            This field is a member of `oneof`_ ``_top_k``.
+        safety_settings (MutableSequence[google.ai.generativelanguage_v1beta3.types.SafetySetting]):
+            A list of unique ``SafetySetting`` instances for blocking
+            unsafe content.
+
+            that will be enforced on the ``GenerateTextRequest.prompt``
+            and ``GenerateTextResponse.candidates``. There should not be
+            more than one setting for each ``SafetyCategory`` type. The
+            API will block any prompts and responses that fail to meet
+            the thresholds set by these settings. This list overrides
+            the default settings for each ``SafetyCategory`` specified
+            in the safety_settings. If there is no ``SafetySetting`` for
+            a given ``SafetyCategory`` provided in the list, the API
+            will use the default safety setting for that category.
+        stop_sequences (MutableSequence[str]):
+            The set of character sequences (up to 5) that
+            will stop output generation. If specified, the
+            API will stop at the first appearance of a stop
+            sequence. The stop sequence will not be included
+            as part of the response.
+    """
+
+    model: str = proto.Field(
+        proto.STRING,
+        number=1,
+    )
+    prompt: "TextPrompt" = proto.Field(
+        proto.MESSAGE,
+        number=2,
+        message="TextPrompt",
+    )
+    temperature: float = proto.Field(
+        proto.FLOAT,
+        number=3,
+        optional=True,
+    )
+    candidate_count: int = proto.Field(
+        proto.INT32,
+        number=4,
+        optional=True,
+    )
+    max_output_tokens: int = proto.Field(
+        proto.INT32,
+        number=5,
+        optional=True,
+    )
+    top_p: float = proto.Field(
+        proto.FLOAT,
+        number=6,
+        optional=True,
+    )
+    top_k: int = proto.Field(
+        proto.INT32,
+        number=7,
+        optional=True,
+    )
+    safety_settings: MutableSequence[safety.SafetySetting] = proto.RepeatedField(
+        proto.MESSAGE,
+        number=8,
+        message=safety.SafetySetting,
+    )
+    stop_sequences: MutableSequence[str] = proto.RepeatedField(
+        proto.STRING,
+        number=9,
+    )
+
+
+class GenerateTextResponse(proto.Message):
+    r"""The response from the model, including candidate completions.
+
+    Attributes:
+        candidates (MutableSequence[google.ai.generativelanguage_v1beta3.types.TextCompletion]):
+            Candidate responses from the model.
+        filters (MutableSequence[google.ai.generativelanguage_v1beta3.types.ContentFilter]):
+            A set of content filtering metadata for the prompt and
+            response text.
+
+            This indicates which ``SafetyCategory``\ (s) blocked a
+            candidate from this response, the lowest ``HarmProbability``
+            that triggered a block, and the HarmThreshold setting for
+            that category. This indicates the smallest change to the
+            ``SafetySettings`` that would be necessary to unblock at
+            least 1 response.
+
+            The blocking is configured by the ``SafetySettings`` in the
+            request (or the default ``SafetySettings`` of the API).
+        safety_feedback (MutableSequence[google.ai.generativelanguage_v1beta3.types.SafetyFeedback]):
+            Returns any safety feedback related to
+            content filtering.
+    """
+
+    candidates: MutableSequence["TextCompletion"] = proto.RepeatedField(
+        proto.MESSAGE,
+        number=1,
+        message="TextCompletion",
+    )
+    filters: MutableSequence[safety.ContentFilter] = proto.RepeatedField(
+        proto.MESSAGE,
+        number=3,
+        message=safety.ContentFilter,
+    )
+    safety_feedback: MutableSequence[safety.SafetyFeedback] = proto.RepeatedField(
+        proto.MESSAGE,
+        number=4,
+        message=safety.SafetyFeedback,
+    )
+
+
+class TextPrompt(proto.Message):
+    r"""Text given to the model as a prompt.
+
+    The Model will use this TextPrompt to Generate a text
+    completion.
+
+    Attributes:
+        text (str):
+            Required. The prompt text.
+    """
+
+    text: str = proto.Field(
+        proto.STRING,
+        number=1,
+    )
+
+
+class TextCompletion(proto.Message):
+    r"""Output text returned from a model.
+
+    .. _oneof: https://proto-plus-python.readthedocs.io/en/stable/fields.html#oneofs-mutually-exclusive-fields
+
+    Attributes:
+        output (str):
+            Output only. The generated text returned from
+            the model.
+        safety_ratings (MutableSequence[google.ai.generativelanguage_v1beta3.types.SafetyRating]):
+            Ratings for the safety of a response.
+
+            There is at most one rating per category.
+        citation_metadata (google.ai.generativelanguage_v1beta3.types.CitationMetadata):
+            Output only. Citation information for model-generated
+            ``output`` in this ``TextCompletion``.
+
+            This field may be populated with attribution information for
+            any text included in the ``output``.
+
+            This field is a member of `oneof`_ ``_citation_metadata``.
+    """
+
+    output: str = proto.Field(
+        proto.STRING,
+        number=1,
+    )
+    safety_ratings: MutableSequence[safety.SafetyRating] = proto.RepeatedField(
+        proto.MESSAGE,
+        number=2,
+        message=safety.SafetyRating,
+    )
+    citation_metadata: citation.CitationMetadata = proto.Field(
+        proto.MESSAGE,
+        number=3,
+        optional=True,
+        message=citation.CitationMetadata,
+    )
+
+
+class EmbedTextRequest(proto.Message):
+    r"""Request to get a text embedding from the model.
+
+    Attributes:
+        model (str):
+            Required. The model name to use with the
+            format model=models/{model}.
+        text (str):
+            Required. The free-form input text that the
+            model will turn into an embedding.
+    """
+
+    model: str = proto.Field(
+        proto.STRING,
+        number=1,
+    )
+    text: str = proto.Field(
+        proto.STRING,
+        number=2,
+    )
+
+
+class EmbedTextResponse(proto.Message):
+    r"""The response to a EmbedTextRequest.
+
+    .. _oneof: https://proto-plus-python.readthedocs.io/en/stable/fields.html#oneofs-mutually-exclusive-fields
+
+    Attributes:
+        embedding (google.ai.generativelanguage_v1beta3.types.Embedding):
+            Output only. The embedding generated from the
+            input text.
+
+            This field is a member of `oneof`_ ``_embedding``.
+    """
+
+    embedding: "Embedding" = proto.Field(
+        proto.MESSAGE,
+        number=1,
+        optional=True,
+        message="Embedding",
+    )
+
+
+class BatchEmbedTextRequest(proto.Message):
+    r"""Batch request to get a text embedding from the model.
+
+    Attributes:
+        model (str):
+            Required. The name of the ``Model`` to use for generating
+            the embedding. Examples: models/embedding-gecko-001
+        texts (MutableSequence[str]):
+            Required. The free-form input texts that the
+            model will turn into an embedding.  The current
+            limit is 100 texts, over which an error will be
+            thrown.
+    """
+
+    model: str = proto.Field(
+        proto.STRING,
+        number=1,
+    )
+    texts: MutableSequence[str] = proto.RepeatedField(
+        proto.STRING,
+        number=2,
+    )
+
+
+class BatchEmbedTextResponse(proto.Message):
+    r"""The response to a EmbedTextRequest.
+
+    Attributes:
+        embeddings (MutableSequence[google.ai.generativelanguage_v1beta3.types.Embedding]):
+            Output only. The embeddings generated from
+            the input text.
+    """
+
+    embeddings: MutableSequence["Embedding"] = proto.RepeatedField(
+        proto.MESSAGE,
+        number=1,
+        message="Embedding",
+    )
+
+
+class Embedding(proto.Message):
+    r"""A list of floats representing the embedding.
+
+    Attributes:
+        value (MutableSequence[float]):
+            The embedding values.
+    """
+
+    value: MutableSequence[float] = proto.RepeatedField(
+        proto.FLOAT,
+        number=1,
+    )
+
+
+class CountTextTokensRequest(proto.Message):
+    r"""Counts the number of tokens in the ``prompt`` sent to a model.
+
+    Models may tokenize text differently, so each model may return a
+    different ``token_count``.
+
+    Attributes:
+        model (str):
+            Required. The model's resource name. This serves as an ID
+            for the Model to use.
+
+            This name should match a model name returned by the
+            ``ListModels`` method.
+
+            Format: ``models/{model}``
+        prompt (google.ai.generativelanguage_v1beta3.types.TextPrompt):
+            Required. The free-form input text given to
+            the model as a prompt.
+    """
+
+    model: str = proto.Field(
+        proto.STRING,
+        number=1,
+    )
+    prompt: "TextPrompt" = proto.Field(
+        proto.MESSAGE,
+        number=2,
+        message="TextPrompt",
+    )
+
+
+class CountTextTokensResponse(proto.Message):
+    r"""A response from ``CountTextTokens``.
+
+    It returns the model's ``token_count`` for the ``prompt``.
+
+    Attributes:
+        token_count (int):
+            The number of tokens that the ``model`` tokenizes the
+            ``prompt`` into.
+
+            Always non-negative.
+    """
+
+    token_count: int = proto.Field(
+        proto.INT32,
+        number=1,
+    )
+
+
+__all__ = tuple(sorted(__protobuf__.manifest))