Add files using upload-large-folder tool

.venv/lib/python3.11/site-packages/google/generativeai/types/answer_types.py

@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+# Copyright 2023 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 Union
+
+from google.generativeai import protos
+
+__all__ = ["Answer"]
+
+FinishReason = protos.Candidate.FinishReason
+
+FinishReasonOptions = Union[int, str, FinishReason]
+
+_FINISH_REASONS: dict[FinishReasonOptions, FinishReason] = {
+    FinishReason.FINISH_REASON_UNSPECIFIED: FinishReason.FINISH_REASON_UNSPECIFIED,
+    0: FinishReason.FINISH_REASON_UNSPECIFIED,
+    "finish_reason_unspecified": FinishReason.FINISH_REASON_UNSPECIFIED,
+    "unspecified": FinishReason.FINISH_REASON_UNSPECIFIED,
+    FinishReason.STOP: FinishReason.STOP,
+    1: FinishReason.STOP,
+    "finish_reason_stop": FinishReason.STOP,
+    "stop": FinishReason.STOP,
+    FinishReason.MAX_TOKENS: FinishReason.MAX_TOKENS,
+    2: FinishReason.MAX_TOKENS,
+    "finish_reason_max_tokens": FinishReason.MAX_TOKENS,
+    "max_tokens": FinishReason.MAX_TOKENS,
+    FinishReason.SAFETY: FinishReason.SAFETY,
+    3: FinishReason.SAFETY,
+    "finish_reason_safety": FinishReason.SAFETY,
+    "safety": FinishReason.SAFETY,
+    FinishReason.RECITATION: FinishReason.RECITATION,
+    4: FinishReason.RECITATION,
+    "finish_reason_recitation": FinishReason.RECITATION,
+    "recitation": FinishReason.RECITATION,
+    FinishReason.OTHER: FinishReason.OTHER,
+    5: FinishReason.OTHER,
+    "finish_reason_other": FinishReason.OTHER,
+    "other": FinishReason.OTHER,
+}
+
+
+def to_finish_reason(x: FinishReasonOptions) -> FinishReason:
+    if isinstance(x, str):
+        x = x.lower()
+    return _FINISH_REASONS[x]

.venv/lib/python3.11/site-packages/google/generativeai/types/caching_types.py

@@ -0,0 +1,83 @@
+# -*- 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
+
+import datetime
+from typing import Union
+from typing_extensions import TypedDict
+
+__all__ = [
+    "ExpireTime",
+    "TTL",
+    "TTLTypes",
+    "ExpireTimeTypes",
+]
+
+
+class TTL(TypedDict):
+    # Represents datetime.datetime.now() + desired ttl
+    seconds: int
+    nanos: int
+
+
+class ExpireTime(TypedDict):
+    # Represents seconds of UTC time since Unix epoch
+    seconds: int
+    nanos: int
+
+
+TTLTypes = Union[TTL, int, datetime.timedelta]
+ExpireTimeTypes = Union[ExpireTime, int, datetime.datetime]
+
+
+def to_optional_ttl(ttl: TTLTypes | None) -> TTL | None:
+    if ttl is None:
+        return None
+    elif isinstance(ttl, datetime.timedelta):
+        return {
+            "seconds": int(ttl.total_seconds()),
+            "nanos": int(ttl.microseconds * 1000),
+        }
+    elif isinstance(ttl, dict):
+        return ttl
+    elif isinstance(ttl, int):
+        return {"seconds": ttl, "nanos": 0}
+    else:
+        raise TypeError(
+            f"Could not convert input to `ttl` \n'" f"  type: {type(ttl)}\n",
+            ttl,
+        )
+
+
+def to_optional_expire_time(expire_time: ExpireTimeTypes | None) -> ExpireTime | None:
+    if expire_time is None:
+        return expire_time
+    elif isinstance(expire_time, datetime.datetime):
+        timestamp = expire_time.timestamp()
+        seconds = int(timestamp)
+        nanos = int((seconds % 1) * 1000)
+        return {
+            "seconds": seconds,
+            "nanos": nanos,
+        }
+    elif isinstance(expire_time, dict):
+        return expire_time
+    elif isinstance(expire_time, int):
+        return {"seconds": expire_time, "nanos": 0}
+    else:
+        raise TypeError(
+            f"Could not convert input to `expire_time` \n'" f"  type: {type(expire_time)}\n",
+            expire_time,
+        )

.venv/lib/python3.11/site-packages/google/generativeai/types/content_types.py

@@ -0,0 +1,985 @@
+# 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 collections.abc import Iterable, Mapping, Sequence
+import io
+import inspect
+import mimetypes
+import pathlib
+import typing
+from typing import Any, Callable, Union
+from typing_extensions import TypedDict
+
+import pydantic
+
+from google.generativeai.types import file_types
+from google.generativeai import protos
+
+if typing.TYPE_CHECKING:
+    import PIL.Image
+    import PIL.ImageFile
+    import IPython.display
+
+    IMAGE_TYPES = (PIL.Image.Image, IPython.display.Image)
+else:
+    IMAGE_TYPES = ()
+    try:
+        import PIL.Image
+        import PIL.ImageFile
+
+        IMAGE_TYPES = IMAGE_TYPES + (PIL.Image.Image,)
+    except ImportError:
+        PIL = None
+
+    try:
+        import IPython.display
+
+        IMAGE_TYPES = IMAGE_TYPES + (IPython.display.Image,)
+    except ImportError:
+        IPython = None
+
+
+__all__ = [
+    "BlobDict",
+    "BlobType",
+    "PartDict",
+    "PartType",
+    "ContentDict",
+    "ContentType",
+    "StrictContentType",
+    "ContentsType",
+    "FunctionDeclaration",
+    "CallableFunctionDeclaration",
+    "FunctionDeclarationType",
+    "Tool",
+    "ToolDict",
+    "ToolsType",
+    "FunctionLibrary",
+    "FunctionLibraryType",
+]
+
+Mode = protos.DynamicRetrievalConfig.Mode
+
+ModeOptions = Union[int, str, Mode]
+
+_MODE: dict[ModeOptions, Mode] = {
+    Mode.MODE_UNSPECIFIED: Mode.MODE_UNSPECIFIED,
+    0: Mode.MODE_UNSPECIFIED,
+    "mode_unspecified": Mode.MODE_UNSPECIFIED,
+    "unspecified": Mode.MODE_UNSPECIFIED,
+    Mode.MODE_DYNAMIC: Mode.MODE_DYNAMIC,
+    1: Mode.MODE_DYNAMIC,
+    "mode_dynamic": Mode.MODE_DYNAMIC,
+    "dynamic": Mode.MODE_DYNAMIC,
+}
+
+
+def to_mode(x: ModeOptions) -> Mode:
+    if isinstance(x, str):
+        x = x.lower()
+    return _MODE[x]
+
+
+def _pil_to_blob(image: PIL.Image.Image) -> protos.Blob:
+    # If the image is a local file, return a file-based blob without any modification.
+    # Otherwise, return a lossless WebP blob (same quality with optimized size).
+    def file_blob(image: PIL.Image.Image) -> protos.Blob | None:
+        if not isinstance(image, PIL.ImageFile.ImageFile) or image.filename is None:
+            return None
+        filename = str(image.filename)
+        if not pathlib.Path(filename).is_file():
+            return None
+
+        mime_type = image.get_format_mimetype()
+        image_bytes = pathlib.Path(filename).read_bytes()
+
+        return protos.Blob(mime_type=mime_type, data=image_bytes)
+
+    def webp_blob(image: PIL.Image.Image) -> protos.Blob:
+        # Reference: https://pillow.readthedocs.io/en/stable/handbook/image-file-formats.html#webp
+        image_io = io.BytesIO()
+        image.save(image_io, format="webp", lossless=True)
+        image_io.seek(0)
+
+        mime_type = "image/webp"
+        image_bytes = image_io.read()
+
+        return protos.Blob(mime_type=mime_type, data=image_bytes)
+
+    return file_blob(image) or webp_blob(image)
+
+
+def image_to_blob(image) -> protos.Blob:
+    if PIL is not None:
+        if isinstance(image, PIL.Image.Image):
+            return _pil_to_blob(image)
+
+    if IPython is not None:
+        if isinstance(image, IPython.display.Image):
+            name = image.filename
+            if name is None:
+                raise ValueError(
+                    "Conversion failed. The `IPython.display.Image` can only be converted if "
+                    "it is constructed from a local file. Please ensure you are using the format: Image(filename='...')."
+                )
+            mime_type, _ = mimetypes.guess_type(name)
+            if mime_type is None:
+                mime_type = "image/unknown"
+
+            return protos.Blob(mime_type=mime_type, data=image.data)
+
+    raise TypeError(
+        "Image conversion failed. The input was expected to be of type `Image` "
+        "(either `PIL.Image.Image` or `IPython.display.Image`).\n"
+        f"However, received an object of type: {type(image)}.\n"
+        f"Object Value: {image}"
+    )
+
+
+class BlobDict(TypedDict):
+    mime_type: str
+    data: bytes
+
+
+def _convert_dict(d: Mapping) -> protos.Content | protos.Part | protos.Blob:
+    if is_content_dict(d):
+        content = dict(d)
+        if isinstance(parts := content["parts"], str):
+            content["parts"] = [parts]
+        content["parts"] = [to_part(part) for part in content["parts"]]
+        return protos.Content(content)
+    elif is_part_dict(d):
+        part = dict(d)
+        if "inline_data" in part:
+            part["inline_data"] = to_blob(part["inline_data"])
+        if "file_data" in part:
+            part["file_data"] = file_types.to_file_data(part["file_data"])
+        return protos.Part(part)
+    elif is_blob_dict(d):
+        blob = d
+        return protos.Blob(blob)
+    else:
+        raise KeyError(
+            "Unable to determine the intended type of the `dict`. "
+            "For `Content`, a 'parts' key is expected. "
+            "For `Part`, either an 'inline_data' or a 'text' key is expected. "
+            "For `Blob`, both 'mime_type' and 'data' keys are expected. "
+            f"However, the provided dictionary has the following keys: {list(d.keys())}"
+        )
+
+
+def is_blob_dict(d):
+    return "mime_type" in d and "data" in d
+
+
+if typing.TYPE_CHECKING:
+    BlobType = Union[
+        protos.Blob, BlobDict, PIL.Image.Image, IPython.display.Image
+    ]  # Any for the images
+else:
+    BlobType = Union[protos.Blob, BlobDict, Any]
+
+
+def to_blob(blob: BlobType) -> protos.Blob:
+    if isinstance(blob, Mapping):
+        blob = _convert_dict(blob)
+
+    if isinstance(blob, protos.Blob):
+        return blob
+    elif isinstance(blob, IMAGE_TYPES):
+        return image_to_blob(blob)
+    else:
+        if isinstance(blob, Mapping):
+            raise KeyError(
+                "Could not recognize the intended type of the `dict`\n" "A content should have "
+            )
+        raise TypeError(
+            "Could not create `Blob`, expected `Blob`, `dict` or an `Image` type"
+            "(`PIL.Image.Image` or `IPython.display.Image`).\n"
+            f"Got a: {type(blob)}\n"
+            f"Value: {blob}"
+        )
+
+
+class PartDict(TypedDict):
+    text: str
+    inline_data: BlobType
+
+
+# When you need a `Part` accept a part object, part-dict, blob or string
+PartType = Union[
+    protos.Part,
+    PartDict,
+    BlobType,
+    str,
+    protos.FunctionCall,
+    protos.FunctionResponse,
+    file_types.FileDataType,
+]
+
+
+def is_part_dict(d):
+    keys = list(d.keys())
+    if len(keys) != 1:
+        return False
+
+    key = keys[0]
+
+    return key in ["text", "inline_data", "function_call", "function_response", "file_data"]
+
+
+def to_part(part: PartType):
+    if isinstance(part, Mapping):
+        part = _convert_dict(part)
+
+    if isinstance(part, protos.Part):
+        return part
+    elif isinstance(part, str):
+        return protos.Part(text=part)
+    elif isinstance(part, protos.FileData):
+        return protos.Part(file_data=part)
+    elif isinstance(part, (protos.File, file_types.File)):
+        return protos.Part(file_data=file_types.to_file_data(part))
+    elif isinstance(part, protos.FunctionCall):
+        return protos.Part(function_call=part)
+    elif isinstance(part, protos.FunctionResponse):
+        return protos.Part(function_response=part)
+
+    else:
+        # Maybe it can be turned into a blob?
+        return protos.Part(inline_data=to_blob(part))
+
+
+class ContentDict(TypedDict):
+    parts: list[PartType]
+    role: str
+
+
+def is_content_dict(d):
+    return "parts" in d
+
+
+# When you need a message accept a `Content` object or dict, a list of parts,
+# or a single part
+ContentType = Union[protos.Content, ContentDict, Iterable[PartType], PartType]
+
+# For generate_content, we're not guessing roles for [[parts],[parts],[parts]] yet.
+StrictContentType = Union[protos.Content, ContentDict]
+
+
+def to_content(content: ContentType):
+    if not content:
+        raise ValueError(
+            "Invalid input: 'content' argument must not be empty. Please provide a non-empty value."
+        )
+
+    if isinstance(content, Mapping):
+        content = _convert_dict(content)
+
+    if isinstance(content, protos.Content):
+        return content
+    elif isinstance(content, Iterable) and not isinstance(content, str):
+        return protos.Content(parts=[to_part(part) for part in content])
+    else:
+        # Maybe this is a Part?
+        return protos.Content(parts=[to_part(content)])
+
+
+def strict_to_content(content: StrictContentType):
+    if isinstance(content, Mapping):
+        content = _convert_dict(content)
+
+    if isinstance(content, protos.Content):
+        return content
+    else:
+        raise TypeError(
+            "Invalid input type. Expected a `protos.Content` or a `dict` with a 'parts' key.\n"
+            f"However, received an object of type: {type(content)}.\n"
+            f"Object Value: {content}"
+        )
+
+
+ContentsType = Union[ContentType, Iterable[StrictContentType], None]
+
+
+def to_contents(contents: ContentsType) -> list[protos.Content]:
+    if contents is None:
+        return []
+
+    if isinstance(contents, Iterable) and not isinstance(contents, (str, Mapping)):
+        try:
+            # strict_to_content so [[parts], [parts]] doesn't assume roles.
+            contents = [strict_to_content(c) for c in contents]
+            return contents
+        except TypeError:
+            # If you get a TypeError here it's probably because that was a list
+            # of parts, not a list of contents, so fall back to `to_content`.
+            pass
+
+    contents = [to_content(contents)]
+    return contents
+
+
+def _schema_for_class(cls: TypedDict) -> dict[str, Any]:
+    schema = _build_schema("dummy", {"dummy": (cls, pydantic.Field())})
+    return schema["properties"]["dummy"]
+
+
+def _schema_for_function(
+    f: Callable[..., Any],
+    *,
+    descriptions: Mapping[str, str] | None = None,
+    required: Sequence[str] | None = None,
+) -> dict[str, Any]:
+    """Generates the OpenAPI Schema for a python function.
+
+    Args:
+        f: The function to generate an OpenAPI Schema for.
+        descriptions: Optional. A `{name: description}` mapping for annotating input
+            arguments of the function with user-provided descriptions. It
+            defaults to an empty dictionary (i.e. there will not be any
+            description for any of the inputs).
+        required: Optional. For the user to specify the set of required arguments in
+            function calls to `f`. If unspecified, it will be automatically
+            inferred from `f`.
+
+    Returns:
+        dict[str, Any]: The OpenAPI Schema for the function `f` in JSON format.
+    """
+    if descriptions is None:
+        descriptions = {}
+    defaults = dict(inspect.signature(f).parameters)
+
+    fields_dict = {}
+    for name, param in defaults.items():
+        if param.kind in (
+            inspect.Parameter.POSITIONAL_OR_KEYWORD,
+            inspect.Parameter.KEYWORD_ONLY,
+            inspect.Parameter.POSITIONAL_ONLY,
+        ):
+            # We do not support default values for now.
+            # default=(
+            #     param.default if param.default != inspect.Parameter.empty
+            #     else None
+            # ),
+            field = pydantic.Field(
+                # We support user-provided descriptions.
+                description=descriptions.get(name, None)
+            )
+
+            # 1. We infer the argument type here: use Any rather than None so
+            # it will not try to auto-infer the type based on the default value.
+            if param.annotation != inspect.Parameter.empty:
+                fields_dict[name] = param.annotation, field
+            else:
+                fields_dict[name] = Any, field
+
+    parameters = _build_schema(f.__name__, fields_dict)
+
+    # 6. Annotate required fields.
+    if required is not None:
+        # We use the user-provided "required" fields if specified.
+        parameters["required"] = required
+    else:
+        # Otherwise we infer it from the function signature.
+        parameters["required"] = [
+            k
+            for k in defaults
+            if (
+                defaults[k].default == inspect.Parameter.empty
+                and defaults[k].kind
+                in (
+                    inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                    inspect.Parameter.KEYWORD_ONLY,
+                    inspect.Parameter.POSITIONAL_ONLY,
+                )
+            )
+        ]
+    schema = dict(name=f.__name__, description=f.__doc__)
+    if parameters["properties"]:
+        schema["parameters"] = parameters
+
+    return schema
+
+
+def _build_schema(fname, fields_dict):
+    parameters = pydantic.create_model(fname, **fields_dict).model_json_schema()
+    defs = parameters.pop("$defs", {})
+    # flatten the defs
+    for name, value in defs.items():
+        unpack_defs(value, defs)
+    unpack_defs(parameters, defs)
+
+    # 5. Nullable fields:
+    #     * https://github.com/pydantic/pydantic/issues/1270
+    #     * https://stackoverflow.com/a/58841311
+    #     * https://github.com/pydantic/pydantic/discussions/4872
+    convert_to_nullable(parameters)
+    add_object_type(parameters)
+    # Postprocessing
+    # 4. Suppress unnecessary title generation:
+    #    * https://github.com/pydantic/pydantic/issues/1051
+    #    * http://cl/586221780
+    strip_titles(parameters)
+    return parameters
+
+
+def unpack_defs(schema, defs):
+    properties = schema.get("properties", None)
+    if properties is None:
+        return
+
+    for name, value in properties.items():
+        ref_key = value.get("$ref", None)
+        if ref_key is not None:
+            ref = defs[ref_key.split("defs/")[-1]]
+            unpack_defs(ref, defs)
+            properties[name] = ref
+            continue
+
+        anyof = value.get("anyOf", None)
+        if anyof is not None:
+            for i, atype in enumerate(anyof):
+                ref_key = atype.get("$ref", None)
+                if ref_key is not None:
+                    ref = defs[ref_key.split("defs/")[-1]]
+                    unpack_defs(ref, defs)
+                    anyof[i] = ref
+            continue
+
+        items = value.get("items", None)
+        if items is not None:
+            ref_key = items.get("$ref", None)
+            if ref_key is not None:
+                ref = defs[ref_key.split("defs/")[-1]]
+                unpack_defs(ref, defs)
+                value["items"] = ref
+                continue
+
+
+def strip_titles(schema):
+    title = schema.pop("title", None)
+
+    properties = schema.get("properties", None)
+    if properties is not None:
+        for name, value in properties.items():
+            strip_titles(value)
+
+    items = schema.get("items", None)
+    if items is not None:
+        strip_titles(items)
+
+
+def add_object_type(schema):
+    properties = schema.get("properties", None)
+    if properties is not None:
+        schema.pop("required", None)
+        schema["type"] = "object"
+        for name, value in properties.items():
+            add_object_type(value)
+
+    items = schema.get("items", None)
+    if items is not None:
+        add_object_type(items)
+
+
+def convert_to_nullable(schema):
+    anyof = schema.pop("anyOf", None)
+    if anyof is not None:
+        if len(anyof) != 2:
+            raise ValueError(
+                "Invalid input: Type Unions are not supported, except for `Optional` types. "
+                "Please provide an `Optional` type or a non-Union type."
+            )
+        a, b = anyof
+        if a == {"type": "null"}:
+            schema.update(b)
+        elif b == {"type": "null"}:
+            schema.update(a)
+        else:
+            raise ValueError(
+                "Invalid input: Type Unions are not supported, except for `Optional` types. "
+                "Please provide an `Optional` type or a non-Union type."
+            )
+        schema["nullable"] = True
+
+    properties = schema.get("properties", None)
+    if properties is not None:
+        for name, value in properties.items():
+            convert_to_nullable(value)
+
+    items = schema.get("items", None)
+    if items is not None:
+        convert_to_nullable(items)
+
+
+def _rename_schema_fields(schema):
+    if schema is None:
+        return schema
+
+    schema = schema.copy()
+
+    type_ = schema.pop("type", None)
+    if type_ is not None:
+        schema["type_"] = type_.upper()
+
+    format_ = schema.pop("format", None)
+    if format_ is not None:
+        schema["format_"] = format_
+
+    items = schema.pop("items", None)
+    if items is not None:
+        schema["items"] = _rename_schema_fields(items)
+
+    properties = schema.pop("properties", None)
+    if properties is not None:
+        schema["properties"] = {k: _rename_schema_fields(v) for k, v in properties.items()}
+
+    return schema
+
+
+class FunctionDeclaration:
+    def __init__(self, *, name: str, description: str, parameters: dict[str, Any] | None = None):
+        """A  class wrapping a `protos.FunctionDeclaration`, describes a function for `genai.GenerativeModel`'s `tools`."""
+        self._proto = protos.FunctionDeclaration(
+            name=name, description=description, parameters=_rename_schema_fields(parameters)
+        )
+
+    @property
+    def name(self) -> str:
+        return self._proto.name
+
+    @property
+    def description(self) -> str:
+        return self._proto.description
+
+    @property
+    def parameters(self) -> protos.Schema:
+        return self._proto.parameters
+
+    @classmethod
+    def from_proto(cls, proto) -> FunctionDeclaration:
+        self = cls(name="", description="", parameters={})
+        self._proto = proto
+        return self
+
+    def to_proto(self) -> protos.FunctionDeclaration:
+        return self._proto
+
+    @staticmethod
+    def from_function(function: Callable[..., Any], descriptions: dict[str, str] | None = None):
+        """Builds a `CallableFunctionDeclaration` from a python function.
+
+        The function should have type annotations.
+
+        This method is able to generate the schema for arguments annotated with types:
+
+        `AllowedTypes = float | int | str | list[AllowedTypes] | dict`
+
+        This method does not yet build a schema for `TypedDict`, that would allow you to specify the dictionary
+        contents. But you can build these manually.
+        """
+
+        if descriptions is None:
+            descriptions = {}
+
+        schema = _schema_for_function(function, descriptions=descriptions)
+
+        return CallableFunctionDeclaration(**schema, function=function)
+
+
+StructType = dict[str, "ValueType"]
+ValueType = Union[float, str, bool, StructType, list["ValueType"], None]
+
+
+class CallableFunctionDeclaration(FunctionDeclaration):
+    """An extension of `FunctionDeclaration` that can be built from a python function, and is callable.
+
+    Note: The python function must have type annotations.
+    """
+
+    def __init__(
+        self,
+        *,
+        name: str,
+        description: str,
+        parameters: dict[str, Any] | None = None,
+        function: Callable[..., Any],
+    ):
+        super().__init__(name=name, description=description, parameters=parameters)
+        self.function = function
+
+    def __call__(self, fc: protos.FunctionCall) -> protos.FunctionResponse:
+        result = self.function(**fc.args)
+        if not isinstance(result, dict):
+            result = {"result": result}
+        return protos.FunctionResponse(name=fc.name, response=result)
+
+
+FunctionDeclarationType = Union[
+    FunctionDeclaration,
+    protos.FunctionDeclaration,
+    dict[str, Any],
+    Callable[..., Any],
+]
+
+
+def _make_function_declaration(
+    fun: FunctionDeclarationType,
+) -> FunctionDeclaration | protos.FunctionDeclaration:
+    if isinstance(fun, (FunctionDeclaration, protos.FunctionDeclaration)):
+        return fun
+    elif isinstance(fun, dict):
+        if "function" in fun:
+            return CallableFunctionDeclaration(**fun)
+        else:
+            return FunctionDeclaration(**fun)
+    elif callable(fun):
+        return CallableFunctionDeclaration.from_function(fun)
+    else:
+        raise TypeError(
+            "Invalid input type. Expected an instance of `genai.FunctionDeclarationType`.\n"
+            f"However, received an object of type: {type(fun)}.\n"
+            f"Object Value: {fun}"
+        )
+
+
+def _encode_fd(fd: FunctionDeclaration | protos.FunctionDeclaration) -> protos.FunctionDeclaration:
+    if isinstance(fd, protos.FunctionDeclaration):
+        return fd
+
+    return fd.to_proto()
+
+
+class DynamicRetrievalConfigDict(TypedDict):
+    mode: protos.DynamicRetrievalConfig.mode
+    dynamic_threshold: float
+
+
+DynamicRetrievalConfig = Union[protos.DynamicRetrievalConfig, DynamicRetrievalConfigDict]
+
+
+class GoogleSearchRetrievalDict(TypedDict):
+    dynamic_retrieval_config: DynamicRetrievalConfig
+
+
+GoogleSearchRetrievalType = Union[protos.GoogleSearchRetrieval, GoogleSearchRetrievalDict]
+
+
+def _make_google_search_retrieval(gsr: GoogleSearchRetrievalType):
+    if isinstance(gsr, protos.GoogleSearchRetrieval):
+        return gsr
+    elif isinstance(gsr, Mapping):
+        drc = gsr.get("dynamic_retrieval_config", None)
+        if drc is not None and isinstance(drc, Mapping):
+            mode = drc.get("mode", None)
+            if mode is not None:
+                mode = to_mode(mode)
+                gsr = gsr.copy()
+                gsr["dynamic_retrieval_config"]["mode"] = mode
+        return protos.GoogleSearchRetrieval(gsr)
+    else:
+        raise TypeError(
+            "Invalid input type. Expected an instance of `genai.GoogleSearchRetrieval`.\n"
+            f"However, received an object of type: {type(gsr)}.\n"
+            f"Object Value: {gsr}"
+        )
+
+
+class Tool:
+    """A wrapper for `protos.Tool`, Contains a collection of related `FunctionDeclaration` objects,
+    protos.CodeExecution object, and protos.GoogleSearchRetrieval object."""
+
+    def __init__(
+        self,
+        *,
+        function_declarations: Iterable[FunctionDeclarationType] | None = None,
+        google_search_retrieval: GoogleSearchRetrievalType | None = None,
+        code_execution: protos.CodeExecution | None = None,
+    ):
+        # The main path doesn't use this but is seems useful.
+        if function_declarations is not None:
+            self._function_declarations = [
+                _make_function_declaration(f) for f in function_declarations
+            ]
+            self._index = {}
+            for fd in self._function_declarations:
+                name = fd.name
+                if name in self._index:
+                    raise ValueError("")
+                self._index[fd.name] = fd
+        else:
+            # Consistent fields
+            self._function_declarations = []
+            self._index = {}
+
+        if google_search_retrieval is not None:
+            self._google_search_retrieval = _make_google_search_retrieval(google_search_retrieval)
+        else:
+            self._google_search_retrieval = None
+
+        self._proto = protos.Tool(
+            function_declarations=[_encode_fd(fd) for fd in self._function_declarations],
+            google_search_retrieval=google_search_retrieval,
+            code_execution=code_execution,
+        )
+
+    @property
+    def function_declarations(self) -> list[FunctionDeclaration | protos.FunctionDeclaration]:
+        return self._function_declarations
+
+    @property
+    def google_search_retrieval(self) -> protos.GoogleSearchRetrieval:
+        return self._google_search_retrieval
+
+    @property
+    def code_execution(self) -> protos.CodeExecution:
+        return self._proto.code_execution
+
+    def __getitem__(
+        self, name: str | protos.FunctionCall
+    ) -> FunctionDeclaration | protos.FunctionDeclaration:
+        if not isinstance(name, str):
+            name = name.name
+
+        return self._index[name]
+
+    def __call__(self, fc: protos.FunctionCall) -> protos.FunctionResponse | None:
+        declaration = self[fc]
+        if not callable(declaration):
+            return None
+
+        return declaration(fc)
+
+    def to_proto(self):
+        return self._proto
+
+
+class ToolDict(TypedDict):
+    function_declarations: list[FunctionDeclarationType]
+
+
+ToolType = Union[
+    str, Tool, protos.Tool, ToolDict, Iterable[FunctionDeclarationType], FunctionDeclarationType
+]
+
+
+def _make_tool(tool: ToolType) -> Tool:
+    if isinstance(tool, Tool):
+        return tool
+    elif isinstance(tool, protos.Tool):
+        if "code_execution" in tool:
+            code_execution = tool.code_execution
+        else:
+            code_execution = None
+
+        if "google_search_retrieval" in tool:
+            google_search_retrieval = tool.google_search_retrieval
+        else:
+            google_search_retrieval = None
+
+        return Tool(
+            function_declarations=tool.function_declarations,
+            google_search_retrieval=google_search_retrieval,
+            code_execution=code_execution,
+        )
+    elif isinstance(tool, dict):
+        if (
+            "function_declarations" in tool
+            or "google_search_retrieval" in tool
+            or "code_execution" in tool
+        ):
+            return Tool(**tool)
+        else:
+            fd = tool
+            return Tool(function_declarations=[protos.FunctionDeclaration(**fd)])
+    elif isinstance(tool, str):
+        if tool.lower() == "code_execution":
+            return Tool(code_execution=protos.CodeExecution())
+        # Check to see if one of the mode enums matches
+        elif tool.lower() == "google_search_retrieval":
+            return Tool(google_search_retrieval=protos.GoogleSearchRetrieval())
+        else:
+            raise ValueError(
+                "The only string that can be passed as a tool is 'code_execution', or one of the specified values for the `mode` parameter for google_search_retrieval."
+            )
+    elif isinstance(tool, protos.CodeExecution):
+        return Tool(code_execution=tool)
+    elif isinstance(tool, protos.GoogleSearchRetrieval):
+        return Tool(google_search_retrieval=tool)
+    elif isinstance(tool, Iterable):
+        return Tool(function_declarations=tool)
+    else:
+        try:
+            return Tool(function_declarations=[tool])
+        except Exception as e:
+            raise TypeError(
+                "Invalid input type. Expected an instance of `genai.ToolType`.\n"
+                f"However, received an object of type: {type(tool)}.\n"
+                f"Object Value: {tool}"
+            ) from e
+
+
+class FunctionLibrary:
+    """A container for a set of `Tool` objects, manages lookup and execution of their functions."""
+
+    def __init__(self, tools: Iterable[ToolType]):
+        tools = _make_tools(tools)
+        self._tools = list(tools)
+        self._index = {}
+        for tool in self._tools:
+            for declaration in tool.function_declarations:
+                name = declaration.name
+                if name in self._index:
+                    raise ValueError(
+                        f"Invalid operation: A `FunctionDeclaration` named '{name}' is already defined. "
+                        "Each `FunctionDeclaration` must have a unique name. Please use a different name."
+                    )
+                self._index[declaration.name] = declaration
+
+    def __getitem__(
+        self, name: str | protos.FunctionCall
+    ) -> FunctionDeclaration | protos.FunctionDeclaration:
+        if not isinstance(name, str):
+            name = name.name
+
+        return self._index[name]
+
+    def __call__(self, fc: protos.FunctionCall) -> protos.Part | None:
+        declaration = self[fc]
+        if not callable(declaration):
+            return None
+
+        response = declaration(fc)
+        return protos.Part(function_response=response)
+
+    def to_proto(self):
+        return [tool.to_proto() for tool in self._tools]
+
+
+ToolsType = Union[Iterable[ToolType], ToolType]
+
+
+def _make_tools(tools: ToolsType) -> list[Tool]:
+    if isinstance(tools, str):
+        if tools.lower() == "code_execution" or tools.lower() == "google_search_retrieval":
+            return [_make_tool(tools)]
+        else:
+            raise ValueError("The only string that can be passed as a tool is 'code_execution'.")
+    elif isinstance(tools, Iterable) and not isinstance(tools, Mapping):
+        tools = [_make_tool(t) for t in tools]
+        if len(tools) > 1 and all(len(t.function_declarations) == 1 for t in tools):
+            # flatten into a single tool.
+            tools = [_make_tool([t.function_declarations[0] for t in tools])]
+        return tools
+    else:
+        tool = tools
+        return [_make_tool(tool)]
+
+
+FunctionLibraryType = Union[FunctionLibrary, ToolsType]
+
+
+def to_function_library(lib: FunctionLibraryType | None) -> FunctionLibrary | None:
+    if lib is None:
+        return lib
+    elif isinstance(lib, FunctionLibrary):
+        return lib
+    else:
+        return FunctionLibrary(tools=lib)
+
+
+FunctionCallingMode = protos.FunctionCallingConfig.Mode
+
+# fmt: off
+_FUNCTION_CALLING_MODE = {
+    1: FunctionCallingMode.AUTO,
+    FunctionCallingMode.AUTO: FunctionCallingMode.AUTO,
+    "mode_auto": FunctionCallingMode.AUTO,
+    "auto": FunctionCallingMode.AUTO,
+
+    2: FunctionCallingMode.ANY,
+    FunctionCallingMode.ANY: FunctionCallingMode.ANY,
+    "mode_any": FunctionCallingMode.ANY,
+    "any": FunctionCallingMode.ANY,
+
+    3: FunctionCallingMode.NONE,
+    FunctionCallingMode.NONE: FunctionCallingMode.NONE,
+    "mode_none": FunctionCallingMode.NONE,
+    "none": FunctionCallingMode.NONE,
+}
+# fmt: on
+
+FunctionCallingModeType = Union[FunctionCallingMode, str, int]
+
+
+def to_function_calling_mode(x: FunctionCallingModeType) -> FunctionCallingMode:
+    if isinstance(x, str):
+        x = x.lower()
+    return _FUNCTION_CALLING_MODE[x]
+
+
+class FunctionCallingConfigDict(TypedDict):
+    mode: FunctionCallingModeType
+    allowed_function_names: list[str]
+
+
+FunctionCallingConfigType = Union[
+    FunctionCallingModeType, FunctionCallingConfigDict, protos.FunctionCallingConfig
+]
+
+
+def to_function_calling_config(obj: FunctionCallingConfigType) -> protos.FunctionCallingConfig:
+    if isinstance(obj, protos.FunctionCallingConfig):
+        return obj
+    elif isinstance(obj, (FunctionCallingMode, str, int)):
+        obj = {"mode": to_function_calling_mode(obj)}
+    elif isinstance(obj, dict):
+        obj = obj.copy()
+        mode = obj.pop("mode")
+        obj["mode"] = to_function_calling_mode(mode)
+    else:
+        raise TypeError(
+            "Invalid input type. Failed to convert input to `protos.FunctionCallingConfig`.\n"
+            f"Received an object of type: {type(obj)}.\n"
+            f"Object Value: {obj}"
+        )
+
+    return protos.FunctionCallingConfig(obj)
+
+
+class ToolConfigDict:
+    function_calling_config: FunctionCallingConfigType
+
+
+ToolConfigType = Union[ToolConfigDict, protos.ToolConfig]
+
+
+def to_tool_config(obj: ToolConfigType) -> protos.ToolConfig:
+    if isinstance(obj, protos.ToolConfig):
+        return obj
+    elif isinstance(obj, dict):
+        fcc = obj.pop("function_calling_config")
+        fcc = to_function_calling_config(fcc)
+        obj["function_calling_config"] = fcc
+        return protos.ToolConfig(**obj)
+    else:
+        raise TypeError(
+            "Invalid input type. Failed to convert input to `protos.ToolConfig`.\n"
+            f"Received an object of type: {type(obj)}.\n"
+            f"Object Value: {obj}"
+        )

.venv/lib/python3.11/site-packages/google/generativeai/types/discuss_types.py

@@ -0,0 +1,208 @@
+# -*- coding: utf-8 -*-
+# Copyright 2023 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.
+"""Type definitions for the discuss service."""
+
+import abc
+import dataclasses
+from typing import Any, Dict, Union, Iterable, Optional, Tuple, List
+from typing_extensions import TypedDict
+
+import google.ai.generativelanguage as glm
+from google.generativeai import string_utils
+
+from google.generativeai.types import safety_types
+from google.generativeai.types import citation_types
+
+
+__all__ = [
+    "MessageDict",
+    "MessageOptions",
+    "MessagesOptions",
+    "ExampleDict",
+    "ExampleOptions",
+    "ExamplesOptions",
+    "MessagePromptDict",
+    "MessagePromptOptions",
+    "ResponseDict",
+    "ChatResponse",
+    "AuthorError",
+]
+
+
+class TokenCount(TypedDict):
+    token_count: int
+
+
+class MessageDict(TypedDict):
+    """A dict representation of a `glm.Message`."""
+
+    author: str
+    content: str
+    citation_metadata: Optional[citation_types.CitationMetadataDict]
+
+
+MessageOptions = Union[str, MessageDict, glm.Message]
+MESSAGE_OPTIONS = (str, dict, glm.Message)
+
+MessagesOptions = Union[
+    MessageOptions,
+    Iterable[MessageOptions],
+]
+MESSAGES_OPTIONS = (MESSAGE_OPTIONS, Iterable)
+
+
+class ExampleDict(TypedDict):
+    """A dict representation of a `glm.Example`."""
+
+    input: MessageOptions
+    output: MessageOptions
+
+
+ExampleOptions = Union[
+    Tuple[MessageOptions, MessageOptions],
+    Iterable[MessageOptions],
+    ExampleDict,
+    glm.Example,
+]
+EXAMPLE_OPTIONS = (glm.Example, dict, Iterable)
+ExamplesOptions = Union[ExampleOptions, Iterable[ExampleOptions]]
+
+
+class MessagePromptDict(TypedDict, total=False):
+    """A dict representation of a `glm.MessagePrompt`."""
+
+    context: str
+    examples: ExamplesOptions
+    messages: MessagesOptions
+
+
+MessagePromptOptions = Union[
+    str,
+    glm.Message,
+    Iterable[Union[str, glm.Message]],
+    MessagePromptDict,
+    glm.MessagePrompt,
+]
+MESSAGE_PROMPT_KEYS = {"context", "examples", "messages"}
+
+
+class ResponseDict(TypedDict):
+    """A dict representation of a `glm.GenerateMessageResponse`."""
+
+    messages: List[MessageDict]
+    candidates: List[MessageDict]
+
+
+@string_utils.prettyprint
+@dataclasses.dataclass(init=False)
+class ChatResponse(abc.ABC):
+    """A chat response from the model.
+
+    * Use `response.last` (settable) for easy access to the text of the last response.
+        (`messages[-1]['content']`)
+    * Use `response.messages` to access the message history (including `.last`).
+    * Use `response.candidates` to access all the responses generated by the model.
+
+    Other attributes are just saved from the arguments to `genai.chat`, so you
+    can easily continue a conversation:
+
+    ```
+    import google.generativeai as genai
+
+    genai.configure(api_key=os.environ['GOOGLE_API_KEY'])
+
+    response = genai.chat(messages=["Hello."])
+    print(response.last) #  'Hello! What can I help you with?'
+    response.reply("Can you tell me a joke?")
+    ```
+
+    See `genai.chat` for more details.
+
+    Attributes:
+        candidates: A list of candidate responses from the model.
+
+            The top candidate is appended to the `messages` field.
+
+            This list will contain a *maximum* of `candidate_count` candidates.
+            It may contain fewer (duplicates are dropped), it will contain at least one.
+
+            Note: The `temperature` field affects the variability of the responses. Low
+            temperatures will return few candidates. Setting `temperature=0` is deterministic,
+            so it will only ever return one candidate.
+        filters: This indicates which `types.SafetyCategory`(s) blocked a
+           candidate from this response, the lowest `types.HarmProbability`
+           that triggered a block, and the `types.HarmThreshold` setting for that category.
+           This indicates the smallest change to the `types.SafetySettings` that would be
+           necessary to unblock at least 1 response.
+
+           The blocking is configured by the `types.SafetySettings` in the request (or the
+           default `types.SafetySettings` of the API).
+        messages: Contains all the `messages` that were passed when the model was called,
+            plus the top `candidate` message.
+        model: The model name.
+        context: Text that should be provided to the model first, to ground the response.
+        examples: Examples of what the model should generate.
+        messages: A snapshot of the conversation history sorted chronologically.
+        temperature: Controls the randomness of the output. Must be positive.
+        candidate_count: The **maximum** number of generated response messages to return.
+        top_k: The maximum number of tokens to consider when sampling.
+        top_p: The maximum cumulative probability of tokens to consider when sampling.
+
+    """
+
+    model: str
+    context: str
+    examples: List[ExampleDict]
+    messages: List[Optional[MessageDict]]
+    temperature: Optional[float]
+    candidate_count: Optional[int]
+    candidates: List[MessageDict]
+    filters: List[safety_types.ContentFilterDict]
+    top_p: Optional[float] = None
+    top_k: Optional[float] = None
+
+    @property
+    @abc.abstractmethod
+    def last(self) -> Optional[str]:
+        """A settable property that provides simple access to the last response string
+
+        A shortcut for `response.messages[0]['content']`.
+        """
+        pass
+
+    def to_dict(self) -> Dict[str, Any]:
+        result = {
+            "model": self.model,
+            "context": self.context,
+            "examples": self.examples,
+            "messages": self.messages,
+            "temperature": self.temperature,
+            "candidate_count": self.candidate_count,
+            "top_p": self.top_p,
+            "top_k": self.top_k,
+            "candidates": self.candidates,
+        }
+        return result
+
+    @abc.abstractmethod
+    def reply(self, message: MessageOptions) -> "ChatResponse":
+        "Add a message to the conversation, and get the model's response."
+        pass
+
+
+class AuthorError(Exception):
+    """Raised by the `chat` (or `reply`) functions when the author list can't be normalized."""
+
+    pass

.venv/lib/python3.11/site-packages/google/generativeai/types/file_types.py

@@ -0,0 +1,143 @@
+# -*- coding: utf-8 -*-
+# Copyright 2023 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
+
+import datetime
+from typing import Any, Union
+from typing_extensions import TypedDict
+
+from google.rpc.status_pb2 import Status
+from google.generativeai.client import get_default_file_client
+
+from google.generativeai import protos
+
+import pprint
+
+
+class File:
+    def __init__(self, proto: protos.File | File | dict):
+        if isinstance(proto, File):
+            proto = proto.to_proto()
+        self._proto = protos.File(proto)
+
+    def to_proto(self) -> protos.File:
+        return self._proto
+
+    def to_dict(self) -> dict[str, Any]:
+        return type(self._proto).to_dict(self._proto, use_integers_for_enums=False)
+
+    def __str__(self):
+        def sort_key(pair):
+            name, value = pair
+            if name == "name":
+                return ""
+            elif "time" in name:
+                return "zz_" + name
+            else:
+                return name
+
+        dict_format = dict(sorted(self.to_dict().items(), key=sort_key))
+        dict_format = pprint.pformat(dict_format, sort_dicts=False)
+        dict_format = "{\n " + dict_format[1:]
+        dict_format = "\n   ".join(dict_format.splitlines())
+        return dict_format.join(["genai.File(", ")"])
+
+    __repr__ = __str__
+
+    @property
+    def name(self) -> str:
+        return self._proto.name
+
+    @property
+    def display_name(self) -> str:
+        return self._proto.display_name
+
+    @property
+    def mime_type(self) -> str:
+        return self._proto.mime_type
+
+    @property
+    def size_bytes(self) -> int:
+        return self._proto.size_bytes
+
+    @property
+    def create_time(self) -> datetime.datetime:
+        return self._proto.create_time
+
+    @property
+    def update_time(self) -> datetime.datetime:
+        return self._proto.update_time
+
+    @property
+    def expiration_time(self) -> datetime.datetime:
+        return self._proto.expiration_time
+
+    @property
+    def sha256_hash(self) -> bytes:
+        return self._proto.sha256_hash
+
+    @property
+    def uri(self) -> str:
+        return self._proto.uri
+
+    @property
+    def state(self) -> protos.File.State:
+        return self._proto.state
+
+    @property
+    def video_metadata(self) -> protos.VideoMetadata:
+        return self._proto.video_metadata
+
+    @property
+    def error(self) -> Status:
+        return self._proto.error
+
+    def delete(self):
+        client = get_default_file_client()
+        client.delete_file(name=self.name)
+
+
+class FileDataDict(TypedDict):
+    mime_type: str
+    file_uri: str
+
+
+FileDataType = Union[FileDataDict, protos.FileData, protos.File, File]
+
+
+def to_file_data(file_data: FileDataType):
+    if isinstance(file_data, dict):
+        if "file_uri" in file_data:
+            file_data = protos.FileData(file_data)
+        else:
+            file_data = protos.File(file_data)
+
+    if isinstance(file_data, File):
+        file_data = file_data.to_proto()
+
+    if isinstance(file_data, protos.File):
+        file_data = protos.FileData(
+            mime_type=file_data.mime_type,
+            file_uri=file_data.uri,
+        )
+
+    if isinstance(file_data, protos.FileData):
+        return file_data
+    else:
+        raise TypeError(
+            f"Invalid input type. Failed to convert input to `FileData`.\n"
+            f"Received an object of type: {type(file_data)}.\n"
+            f"Object Value: {file_data}"
+        )

.venv/lib/python3.11/site-packages/google/generativeai/types/generation_types.py

@@ -0,0 +1,759 @@
+# -*- coding: utf-8 -*-
+# Copyright 2023 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
+
+import collections
+import contextlib
+from collections.abc import Iterable, AsyncIterable, Mapping
+import dataclasses
+import itertools
+import json
+import sys
+import textwrap
+from typing import Union, Any
+from typing_extensions import TypedDict
+import types
+
+import google.protobuf.json_format
+import google.api_core.exceptions
+
+from google.generativeai import protos
+from google.generativeai import string_utils
+from google.generativeai.types import content_types
+from google.generativeai.responder import _rename_schema_fields
+
+__all__ = [
+    "AsyncGenerateContentResponse",
+    "BlockedPromptException",
+    "StopCandidateException",
+    "IncompleteIterationError",
+    "BrokenResponseError",
+    "GenerationConfigDict",
+    "GenerationConfigType",
+    "GenerationConfig",
+    "GenerateContentResponse",
+]
+
+if sys.version_info < (3, 10):
+
+    def aiter(obj):
+        return obj.__aiter__()
+
+    async def anext(obj, default=None):
+        try:
+            return await obj.__anext__()
+        except StopAsyncIteration:
+            if default is not None:
+                return default
+            else:
+                raise
+
+
+class BlockedPromptException(Exception):
+    pass
+
+
+class StopCandidateException(Exception):
+    pass
+
+
+class IncompleteIterationError(Exception):
+    pass
+
+
+class BrokenResponseError(Exception):
+    pass
+
+
+class GenerationConfigDict(TypedDict, total=False):
+    # TODO(markdaoust): Python 3.11+ use `NotRequired`, ref: https://peps.python.org/pep-0655/
+    candidate_count: int
+    stop_sequences: Iterable[str]
+    max_output_tokens: int
+    temperature: float
+    response_mime_type: str
+    response_schema: protos.Schema | Mapping[str, Any]  # fmt: off
+    presence_penalty: float
+    frequency_penalty: float
+
+
+@dataclasses.dataclass
+class GenerationConfig:
+    """A simple dataclass used to configure the generation parameters of `GenerativeModel.generate_content`.
+
+    Attributes:
+        candidate_count:
+            Number of generated responses to return.
+        stop_sequences:
+            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.
+        max_output_tokens:
+            The maximum number of tokens to include in a
+            candidate.
+
+            If unset, this will default to output_token_limit specified
+            in the model's specification.
+        temperature:
+            Controls the randomness of the output. Note: The
+            default value varies by model, see the `Model.temperature`
+            attribute of the `Model` returned the `genai.get_model`
+            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.
+        top_p:
+            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
+            `genai.get_model` function.
+
+        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
+            `genai.get_model` function.
+        response_mime_type:
+            Optional. Output response mimetype of the generated candidate text.
+
+            Supported mimetype:
+                `text/plain`: (default) Text output.
+                `text/x-enum`: for use with a string-enum in `response_schema`
+                `application/json`: JSON response in the candidates.
+
+        response_schema:
+            Optional. Specifies the format of the JSON requested if response_mime_type is
+            `application/json`.
+        presence_penalty:
+            Optional.
+        frequency_penalty:
+            Optional.
+    """
+
+    candidate_count: int | None = None
+    stop_sequences: Iterable[str] | None = None
+    max_output_tokens: int | None = None
+    temperature: float | None = None
+    top_p: float | None = None
+    top_k: int | None = None
+    response_mime_type: str | None = None
+    response_schema: protos.Schema | Mapping[str, Any] | type | None = None
+    presence_penalty: float | None = None
+    frequency_penalty: float | None = None
+
+
+GenerationConfigType = Union[protos.GenerationConfig, GenerationConfigDict, GenerationConfig]
+
+
+def _normalize_schema(generation_config):
+    # Convert response_schema to protos.Schema for request
+    response_schema = generation_config.get("response_schema", None)
+    if response_schema is None:
+        return
+
+    if isinstance(response_schema, protos.Schema):
+        return
+
+    if isinstance(response_schema, type):
+        response_schema = content_types._schema_for_class(response_schema)
+    elif isinstance(response_schema, types.GenericAlias):
+        if not str(response_schema).startswith("list["):
+            raise ValueError(
+                f"Invalid input: Could not understand the type of '{response_schema}'. "
+                "Expected one of the following types: `int`, `float`, `str`, `bool`, `enum`, "
+                "`typing_extensions.TypedDict`, `dataclass` or `list[...]`."
+            )
+        response_schema = content_types._schema_for_class(response_schema)
+
+    response_schema = _rename_schema_fields(response_schema)
+    generation_config["response_schema"] = protos.Schema(response_schema)
+
+
+def to_generation_config_dict(generation_config: GenerationConfigType):
+    if generation_config is None:
+        return {}
+    elif isinstance(generation_config, protos.GenerationConfig):
+        schema = generation_config.response_schema
+        generation_config = type(generation_config).to_dict(
+            generation_config
+        )  # pytype: disable=attribute-error
+        generation_config["response_schema"] = schema
+        return generation_config
+    elif isinstance(generation_config, GenerationConfig):
+        generation_config = dataclasses.asdict(generation_config)
+        _normalize_schema(generation_config)
+        return {key: value for key, value in generation_config.items() if value is not None}
+    elif hasattr(generation_config, "keys"):
+        generation_config = dict(generation_config)
+        _normalize_schema(generation_config)
+        return generation_config
+    else:
+        raise TypeError(
+            "Invalid input type. Expected a `dict` or `GenerationConfig` for `generation_config`.\n"
+            f"However, received an object of type: {type(generation_config)}.\n"
+            f"Object Value: {generation_config}"
+        )
+
+
+def _join_citation_metadatas(
+    citation_metadatas: Iterable[protos.CitationMetadata],
+):
+    citation_metadatas = list(citation_metadatas)
+    return citation_metadatas[-1]
+
+
+def _join_safety_ratings_lists(
+    safety_ratings_lists: Iterable[list[protos.SafetyRating]],
+):
+    ratings = {}
+    blocked = collections.defaultdict(list)
+
+    for safety_ratings_list in safety_ratings_lists:
+        for rating in safety_ratings_list:
+            ratings[rating.category] = rating.probability
+            blocked[rating.category].append(rating.blocked)
+
+    blocked = {category: any(blocked) for category, blocked in blocked.items()}
+
+    safety_list = []
+    for (category, probability), blocked in zip(ratings.items(), blocked.values()):
+        safety_list.append(
+            protos.SafetyRating(category=category, probability=probability, blocked=blocked)
+        )
+
+    return safety_list
+
+
+def _join_contents(contents: Iterable[protos.Content]):
+    contents = tuple(contents)
+    roles = [c.role for c in contents if c.role]
+    if roles:
+        role = roles[0]
+    else:
+        role = ""
+
+    parts = []
+    for content in contents:
+        parts.extend(content.parts)
+
+    merged_parts = []
+    last = parts[0]
+    for part in parts[1:]:
+        if "text" in last and "text" in part:
+            last = protos.Part(text=last.text + part.text)
+            continue
+
+        # Can we merge the new thing into last?
+        # If not, put last in list of parts, and new thing becomes last
+        if "executable_code" in last and "executable_code" in part:
+            last = protos.Part(
+                executable_code=_join_executable_code(last.executable_code, part.executable_code)
+            )
+            continue
+
+        if "code_execution_result" in last and "code_execution_result" in part:
+            last = protos.Part(
+                code_execution_result=_join_code_execution_result(
+                    last.code_execution_result, part.code_execution_result
+                )
+            )
+            continue
+
+        merged_parts.append(last)
+        last = part
+
+    merged_parts.append(last)
+
+    return protos.Content(
+        role=role,
+        parts=merged_parts,
+    )
+
+
+def _join_executable_code(code_1, code_2):
+    return protos.ExecutableCode(language=code_1.language, code=code_1.code + code_2.code)
+
+
+def _join_code_execution_result(result_1, result_2):
+    return protos.CodeExecutionResult(
+        outcome=result_2.outcome, output=result_1.output + result_2.output
+    )
+
+
+def _join_candidates(candidates: Iterable[protos.Candidate]):
+    """Joins stream chunks of a single candidate."""
+    candidates = tuple(candidates)
+
+    index = candidates[0].index  # These should all be the same.
+
+    return protos.Candidate(
+        index=index,
+        content=_join_contents([c.content for c in candidates]),
+        finish_reason=candidates[-1].finish_reason,
+        safety_ratings=_join_safety_ratings_lists([c.safety_ratings for c in candidates]),
+        citation_metadata=_join_citation_metadatas([c.citation_metadata for c in candidates]),
+        token_count=candidates[-1].token_count,
+    )
+
+
+def _join_candidate_lists(candidate_lists: Iterable[list[protos.Candidate]]):
+    """Joins stream chunks where each chunk is a list of candidate chunks."""
+    # Assuming that is a candidate ends, it is no longer returned in the list of
+    # candidates and that's why candidates have an index
+    candidates = collections.defaultdict(list)
+    for candidate_list in candidate_lists:
+        for candidate in candidate_list:
+            candidates[candidate.index].append(candidate)
+
+    new_candidates = []
+    for index, candidate_parts in sorted(candidates.items()):
+        new_candidates.append(_join_candidates(candidate_parts))
+
+    return new_candidates
+
+
+def _join_prompt_feedbacks(
+    prompt_feedbacks: Iterable[protos.GenerateContentResponse.PromptFeedback],
+):
+    # Always return the first prompt feedback.
+    return next(iter(prompt_feedbacks))
+
+
+def _join_chunks(chunks: Iterable[protos.GenerateContentResponse]):
+    chunks = tuple(chunks)
+    if "usage_metadata" in chunks[-1]:
+        usage_metadata = chunks[-1].usage_metadata
+    else:
+        usage_metadata = None
+
+    if "model_version" in chunks[-1]:
+        model_version = chunks[-1].model_version
+    else:
+        model_version = None
+
+    return protos.GenerateContentResponse(
+        candidates=_join_candidate_lists(c.candidates for c in chunks),
+        prompt_feedback=_join_prompt_feedbacks(c.prompt_feedback for c in chunks),
+        usage_metadata=usage_metadata,
+        model_version=model_version,
+    )
+
+
+_INCOMPLETE_ITERATION_MESSAGE = """\
+Please let the response complete iteration before accessing the final accumulated
+attributes (or call `response.resolve()`)"""
+
+
+class BaseGenerateContentResponse:
+    def __init__(
+        self,
+        done: bool,
+        iterator: (
+            None
+            | Iterable[protos.GenerateContentResponse]
+            | AsyncIterable[protos.GenerateContentResponse]
+        ),
+        result: protos.GenerateContentResponse,
+        chunks: Iterable[protos.GenerateContentResponse] | None = None,
+    ):
+        self._done = done
+        self._iterator = iterator
+        self._result = result
+        if chunks is None:
+            self._chunks = [result]
+        else:
+            self._chunks = list(chunks)
+        if result.prompt_feedback.block_reason:
+            self._error = BlockedPromptException(result)
+        else:
+            self._error = None
+
+    def to_dict(self):
+        """Returns the result as a JSON-compatible dict.
+
+        Note: This doesn't capture the iterator state when streaming, it only captures the accumulated
+        `GenerateContentResponse` fields.
+
+        >>> import json
+        >>> response = model.generate_content('Hello?')
+        >>> json.dumps(response.to_dict())
+        """
+        return type(self._result).to_dict(self._result)
+
+    @property
+    def candidates(self):
+        """The list of candidate responses.
+
+        Raises:
+            IncompleteIterationError: With `stream=True` if iteration over the stream was not completed.
+        """
+        if not self._done:
+            raise IncompleteIterationError(_INCOMPLETE_ITERATION_MESSAGE)
+        return self._result.candidates
+
+    @property
+    def parts(self):
+        """A quick accessor equivalent to `self.candidates[0].content.parts`
+
+        Raises:
+            ValueError: If the candidate list does not contain exactly one candidate.
+        """
+        candidates = self.candidates
+        if not candidates:
+            msg = (
+                "Invalid operation: The `response.parts` quick accessor requires a single candidate, "
+                "but but `response.candidates` is empty."
+            )
+            if self.prompt_feedback:
+                raise ValueError(
+                    msg + "\nThis appears to be caused by a blocked prompt, "
+                    f"see `response.prompt_feedback`: {self.prompt_feedback}"
+                )
+            else:
+                raise ValueError(msg)
+
+        if len(candidates) > 1:
+            raise ValueError(
+                "Invalid operation: The `response.parts` quick accessor retrieves the parts for a single candidate. "
+                "This response contains multiple candidates, please use `result.candidates[index].text`."
+            )
+        parts = candidates[0].content.parts
+        return parts
+
+    @property
+    def text(self):
+        """A quick accessor equivalent to `self.candidates[0].content.parts[0].text`
+
+        Raises:
+            ValueError: If the candidate list or parts list does not contain exactly one entry.
+        """
+        parts = self.parts
+        if not parts:
+            candidate = self.candidates[0]
+
+            fr = candidate.finish_reason
+            FinishReason = protos.Candidate.FinishReason
+
+            msg = (
+                "Invalid operation: The `response.text` quick accessor requires the response to contain a valid "
+                "`Part`, but none were returned. The candidate's "
+                f"[finish_reason](https://ai.google.dev/api/generate-content#finishreason) is {fr}."
+            )
+
+            if fr is FinishReason.FINISH_REASON_UNSPECIFIED:
+                raise ValueError(msg)
+            elif fr is FinishReason.STOP:
+                raise ValueError(msg)
+            elif fr is FinishReason.MAX_TOKENS:
+                raise ValueError(msg)
+            elif fr is FinishReason.SAFETY:
+                raise ValueError(
+                    msg + f" The candidate's safety_ratings are: {candidate.safety_ratings}.",
+                    candidate.safety_ratings,
+                )
+            elif fr is FinishReason.RECITATION:
+                raise ValueError(
+                    msg + " Meaning that the model was reciting from copyrighted material."
+                )
+            elif fr is FinishReason.LANGUAGE:
+                raise ValueError(msg + " Meaning the response was using an unsupported language.")
+            elif fr is FinishReason.OTHER:
+                raise ValueError(msg)
+            elif fr is FinishReason.BLOCKLIST:
+                raise ValueError(msg)
+            elif fr is FinishReason.PROHIBITED_CONTENT:
+                raise ValueError(msg)
+            elif fr is FinishReason.SPII:
+                raise ValueError(msg + " SPII - Sensitive Personally Identifiable Information.")
+            elif fr is FinishReason.MALFORMED_FUNCTION_CALL:
+                raise ValueError(
+                    msg + " Meaning that model generated a `FunctionCall` that was invalid. "
+                    "Setting the "
+                    "[Function calling mode](https://ai.google.dev/gemini-api/docs/function-calling#function_calling_mode) "
+                    "to `ANY` can fix this because it enables constrained decoding."
+                )
+            else:
+                raise ValueError(msg)
+
+        texts = []
+        for part in parts:
+            if "text" in part:
+                texts.append(part.text)
+                continue
+            if "executable_code" in part:
+                language = part.executable_code.language.name.lower()
+                if language == "language_unspecified":
+                    language = ""
+                else:
+                    language = f" {language}"
+                texts.extend([f"```{language}", part.executable_code.code.lstrip("\n"), "```"])
+                continue
+            if "code_execution_result" in part:
+                outcome_result = part.code_execution_result.outcome.name.lower().replace(
+                    "outcome_", ""
+                )
+                if outcome_result == "ok" or outcome_result == "unspecified":
+                    outcome_result = ""
+                else:
+                    outcome_result = f" {outcome_result}"
+                texts.extend([f"```{outcome_result}", part.code_execution_result.output, "```"])
+                continue
+
+            part_type = protos.Part.pb(part).whichOneof("data")
+            raise ValueError(f"Could not convert `part.{part_type}` to text.")
+
+        return "\n".join(texts)
+
+    @property
+    def prompt_feedback(self):
+        return self._result.prompt_feedback
+
+    @property
+    def usage_metadata(self):
+        return self._result.usage_metadata
+
+    @property
+    def model_version(self):
+        return self._result.model_version
+
+    def __str__(self) -> str:
+        if self._done:
+            _iterator = "None"
+        else:
+            _iterator = f"<{self._iterator.__class__.__name__}>"
+
+        as_dict = type(self._result).to_dict(
+            self._result, use_integers_for_enums=False, including_default_value_fields=False
+        )
+        json_str = json.dumps(as_dict, indent=2)
+
+        _result = f"protos.GenerateContentResponse({json_str})"
+        _result = _result.replace("\n", "\n                    ")
+
+        if self._error:
+
+            _error = f",\nerror={repr(self._error)}"
+        else:
+            _error = ""
+
+        return (
+            textwrap.dedent(
+                f"""\
+                response:
+                {type(self).__name__}(
+                    done={self._done},
+                    iterator={_iterator},
+                    result={_result},
+                )"""
+            )
+            + _error
+        )
+
+    __repr__ = __str__
+
+
+@contextlib.contextmanager
+def rewrite_stream_error():
+    try:
+        yield
+    except (google.protobuf.json_format.ParseError, AttributeError) as e:
+        raise google.api_core.exceptions.BadRequest(
+            "Unknown error trying to retrieve streaming response. "
+            "Please retry with `stream=False` for more details."
+        )
+
+
+GENERATE_CONTENT_RESPONSE_DOC = """Instances of this class manage the response of the `generate_content` method.
+
+    These are returned by `GenerativeModel.generate_content` and `ChatSession.send_message`.
+    This object is based on the low level `protos.GenerateContentResponse` class which just has `prompt_feedback`
+    and `candidates` attributes. This class adds several quick accessors for common use cases.
+
+    The same object type is returned for both `stream=True/False`.
+
+    ### Streaming
+
+    When you pass `stream=True` to `GenerativeModel.generate_content` or `ChatSession.send_message`,
+    iterate over this object to receive chunks of the response:
+
+    ```
+    response = model.generate_content(..., stream=True):
+    for chunk in response:
+      print(chunk.text)
+    ```
+
+    `GenerateContentResponse.prompt_feedback` is available immediately but
+    `GenerateContentResponse.candidates`, and all the attributes derived from them (`.text`, `.parts`),
+    are only available after the iteration is complete.
+    """
+
+ASYNC_GENERATE_CONTENT_RESPONSE_DOC = (
+    """This is the async version of `genai.GenerateContentResponse`."""
+)
+
+
+@string_utils.set_doc(GENERATE_CONTENT_RESPONSE_DOC)
+class GenerateContentResponse(BaseGenerateContentResponse):
+    @classmethod
+    def from_iterator(cls, iterator: Iterable[protos.GenerateContentResponse]):
+        iterator = iter(iterator)
+        with rewrite_stream_error():
+            response = next(iterator)
+
+        return cls(
+            done=False,
+            iterator=iterator,
+            result=response,
+        )
+
+    @classmethod
+    def from_response(cls, response: protos.GenerateContentResponse):
+        return cls(
+            done=True,
+            iterator=None,
+            result=response,
+        )
+
+    def __iter__(self):
+        # This is not thread safe.
+        if self._done:
+            for chunk in self._chunks:
+                yield GenerateContentResponse.from_response(chunk)
+            return
+
+        # Always have the next chunk available.
+        if len(self._chunks) == 0:
+            self._chunks.append(next(self._iterator))
+
+        for n in itertools.count():
+            if self._error:
+                raise self._error
+
+            if n >= len(self._chunks) - 1:
+                # Look ahead for a new item, so that you know the stream is done
+                # when you yield the last item.
+                if self._done:
+                    return
+
+                try:
+                    item = next(self._iterator)
+                except StopIteration:
+                    self._done = True
+                except Exception as e:
+                    self._error = e
+                    self._done = True
+                else:
+                    self._chunks.append(item)
+                    self._result = _join_chunks([self._result, item])
+
+            item = self._chunks[n]
+
+            item = GenerateContentResponse.from_response(item)
+            yield item
+
+    def resolve(self):
+        if self._done:
+            return
+
+        for _ in self:
+            pass
+
+
+@string_utils.set_doc(ASYNC_GENERATE_CONTENT_RESPONSE_DOC)
+class AsyncGenerateContentResponse(BaseGenerateContentResponse):
+    @classmethod
+    async def from_aiterator(cls, iterator: AsyncIterable[protos.GenerateContentResponse]):
+        iterator = aiter(iterator)  # type: ignore
+        with rewrite_stream_error():
+            response = await anext(iterator)  # type: ignore
+
+        return cls(
+            done=False,
+            iterator=iterator,
+            result=response,
+        )
+
+    @classmethod
+    def from_response(cls, response: protos.GenerateContentResponse):
+        return cls(
+            done=True,
+            iterator=None,
+            result=response,
+        )
+
+    async def __aiter__(self):
+        # This is not thread safe.
+        if self._done:
+            for chunk in self._chunks:
+                yield GenerateContentResponse.from_response(chunk)
+            return
+
+        # Always have the next chunk available.
+        if len(self._chunks) == 0:
+            self._chunks.append(await anext(self._iterator))  # type: ignore
+
+        for n in itertools.count():
+            if self._error:
+                raise self._error
+
+            if n >= len(self._chunks) - 1:
+                # Look ahead for a new item, so that you know the stream is done
+                # when you yield the last item.
+                if self._done:
+                    return
+
+                try:
+                    item = await anext(self._iterator)  # type: ignore
+                except StopAsyncIteration:
+                    self._done = True
+                except Exception as e:
+                    self._error = e
+                    self._done = True
+                else:
+                    self._chunks.append(item)
+                    self._result = _join_chunks([self._result, item])
+
+            item = self._chunks[n]
+
+            item = GenerateContentResponse.from_response(item)
+            yield item
+
+    async def resolve(self):
+        if self._done:
+            return
+
+        async for _ in self:
+            pass

.venv/lib/python3.11/site-packages/google/generativeai/types/image_types/_image_types.py

@@ -0,0 +1,440 @@
+from __future__ import annotations
+
+import base64
+import io
+import json
+import mimetypes
+import os
+import pathlib
+import typing
+from typing import Any, Dict, Optional, Union
+
+import httplib2
+import threading
+
+import googleapiclient.http
+
+from google.generativeai import protos
+
+# pylint: disable=g-import-not-at-top
+if typing.TYPE_CHECKING:
+    import PIL.Image
+    import PIL.ImageFile
+    import IPython.display
+
+    _IMPORTED_IMAGE_TYPES = (PIL.Image.Image, IPython.display.Image)
+    ImageType = Union["Image", PIL.Image.Image, IPython.display.Image]
+else:
+    _IMPORTED_IMAGE_TYPES = ()
+    try:
+        import PIL.Image
+        import PIL.ImageFile
+
+        _IMPORTED_IMAGE_TYPES = _IMPORTED_IMAGE_TYPES + (PIL.Image.Image,)
+    except ImportError:
+        PIL = None
+
+    try:
+        import IPython.display
+
+        IMAGE_TYPES = _IMPORTED_IMAGE_TYPES + (IPython.display.Image,)
+    except ImportError:
+        IPython = None
+
+    ImageType = Union["Image", "PIL.Image.Image", "IPython.display.Image"]
+# pylint: enable=g-import-not-at-top
+
+__all__ = [
+    "Image",
+    "GeneratedImage",
+    "to_image",
+    "check_watermark",
+    "CheckWatermarkResult",
+    "ImageType",
+    "Video",
+    "GeneratedVideo",
+]
+
+
+def _pil_to_blob(image: PIL.Image.Image) -> protos.Blob:
+    # If the image is a local file, return a file-based blob without any modification.
+    # Otherwise, return a lossless WebP blob (same quality with optimized size).
+    def file_blob(image: PIL.Image.Image) -> Union[protos.Blob, None]:
+        if not isinstance(image, PIL.ImageFile.ImageFile) or image.filename is None:
+            return None
+        filename = str(image.filename)
+        if not pathlib.Path(filename).is_file():
+            return None
+
+        mime_type = image.get_format_mimetype()
+        image_bytes = pathlib.Path(filename).read_bytes()
+
+        return protos.Blob(mime_type=mime_type, data=image_bytes)
+
+    def webp_blob(image: PIL.Image.Image) -> protos.Blob:
+        # Reference: https://pillow.readthedocs.io/en/stable/handbook/image-file-formats.html#webp
+        image_io = io.BytesIO()
+        image.save(image_io, format="webp", lossless=True)
+        image_io.seek(0)
+
+        mime_type = "image/webp"
+        image_bytes = image_io.read()
+
+        return protos.Blob(mime_type=mime_type, data=image_bytes)
+
+    return file_blob(image) or webp_blob(image)
+
+
+def image_to_blob(image: ImageType) -> protos.Blob:
+    if PIL is not None:
+        if isinstance(image, PIL.Image.Image):
+            return _pil_to_blob(image)
+
+    if IPython is not None:
+        if isinstance(image, IPython.display.Image):
+            name = image.filename
+            if name is None:
+                raise ValueError(
+                    "Conversion failed. The `IPython.display.Image` can only be converted if "
+                    "it is constructed from a local file. Please ensure you are using the format: Image(filename='...')."
+                )
+            mime_type, _ = mimetypes.guess_type(name)
+            if mime_type is None:
+                mime_type = "image/unknown"
+
+            return protos.Blob(mime_type=mime_type, data=image.data)
+
+    if isinstance(image, Image):
+        return protos.Blob(mime_type=image._mime_type, data=image._image_bytes)
+
+    raise TypeError(
+        "Image conversion failed. The input was expected to be of type `Image` "
+        "(either `PIL.Image.Image` or `IPython.display.Image`).\n"
+        f"However, received an object of type: {type(image)}.\n"
+        f"Object Value: {image}"
+    )
+
+
+class CheckWatermarkResult:
+    def __init__(self, predictions):
+        self._predictions = predictions
+
+    @property
+    def decision(self):
+        return self._predictions[0]["decision"]
+
+    def __str__(self):
+        return f"CheckWatermarkResult([{{'decision': {self.decision!r}}}])"
+
+    def __bool__(self):
+        decision = self.decision
+        if decision == "ACCEPT":
+            return True
+        elif decision == "REJECT":
+            return False
+        else:
+            raise ValueError("Unrecognized result")
+
+
+def to_image(img: Union[pathlib.Path, ImageType]) -> Image:
+    if isinstance(img, Image):
+        pass
+    elif isinstance(img, pathlib.Path):
+        img = Image.load_from_file(img)
+    elif IPython.display is not None and isinstance(img, IPython.display.Image):
+        img = Image(image_bytes=img.data)
+    elif PIL.Image is not None and isinstance(img, PIL.Image.Image):
+        blob = _pil_to_blob(img)
+        img = Image(image_bytes=blob.data)
+    elif isinstance(img, protos.Blob):
+        img = Image(image_bytes=img.data)
+    else:
+        raise TypeError(
+            f"Not implemented: Could not convert a {type(img)} into `Image`\n    {img=}"
+        )
+
+    return img
+
+
+class Image:
+    """Image."""
+
+    __module__ = "vertexai.vision_models"
+
+    _loaded_bytes: Optional[bytes] = None
+    _loaded_image: Optional["PIL.Image.Image"] = None
+
+    def __init__(
+        self,
+        image_bytes: Optional[bytes],
+    ):
+        """Creates an `Image` object.
+
+        Args:
+            image_bytes: Image file bytes. Image can be in PNG or JPEG format.
+        """
+        self._image_bytes = image_bytes
+
+    @staticmethod
+    def load_from_file(location: os.PathLike) -> "Image":
+        """Loads image from local file.
+
+        Args:
+            location: Local path from where to load
+                the image.
+
+        Returns:
+            Loaded image as an `Image` object.
+        """
+        # Load image from local path
+        image_bytes = pathlib.Path(location).read_bytes()
+        image = Image(image_bytes=image_bytes)
+        return image
+
+    @property
+    def _image_bytes(self) -> bytes:
+        return self._loaded_bytes
+
+    @_image_bytes.setter
+    def _image_bytes(self, value: bytes):
+        self._loaded_bytes = value
+
+    @property
+    def _pil_image(self) -> "PIL.Image.Image":  # type: ignore
+        if self._loaded_image is None:
+            if not PIL:
+                raise RuntimeError(
+                    "The PIL module is not available. Please install the Pillow package."
+                )
+            self._loaded_image = PIL.Image.open(io.BytesIO(self._image_bytes))
+        return self._loaded_image
+
+    @property
+    def _size(self):
+        return self._pil_image.size
+
+    @property
+    def _mime_type(self) -> str:
+        """Returns the MIME type of the image."""
+        import PIL
+
+        return PIL.Image.MIME.get(self._pil_image.format, "image/jpeg")
+
+    def show(self):
+        """Shows the image.
+
+        This method only works when in a notebook environment.
+        """
+        if PIL and IPython:
+            IPython.display.display(self._pil_image)
+
+    def save(self, location: str):
+        """Saves image to a file.
+
+        Args:
+            location: Local path where to save the image.
+        """
+        pathlib.Path(location).write_bytes(self._image_bytes)
+
+    def _as_base64_string(self) -> str:
+        """Encodes image using the base64 encoding.
+
+        Returns:
+            Base64 encoding of the image as a string.
+        """
+        # ! b64encode returns `bytes` object, not `str`.
+        # We need to convert `bytes` to `str`, otherwise we get service error:
+        # "received initial metadata size exceeds limit"
+        return base64.b64encode(self._image_bytes).decode("ascii")
+
+    def _repr_png_(self):
+        return self._pil_image._repr_png_()  # type:ignore
+
+
+IMAGE_TYPES = _IMPORTED_IMAGE_TYPES + (Image,)
+
+
+_EXIF_USER_COMMENT_TAG_IDX = 0x9286
+_IMAGE_GENERATION_PARAMETERS_EXIF_KEY = (
+    "google.cloud.vertexai.image_generation.image_generation_parameters"
+)
+
+
+class GeneratedImage(Image):
+    """Generated image."""
+
+    __module__ = "google.generativeai"
+
+    def __init__(
+        self,
+        image_bytes: Optional[bytes],
+        generation_parameters: Dict[str, Any],
+    ):
+        """Creates a `GeneratedImage` object.
+
+        Args:
+            image_bytes: Image file bytes. Image can be in PNG or JPEG format.
+            generation_parameters: Image generation parameter values.
+        """
+        super().__init__(image_bytes=image_bytes)
+        self._generation_parameters = generation_parameters
+
+    @property
+    def generation_parameters(self):
+        """Image generation parameters as a dictionary."""
+        return self._generation_parameters
+
+    @staticmethod
+    def load_from_file(location: os.PathLike) -> "GeneratedImage":
+        """Loads image from file.
+
+        Args:
+            location: Local path from where to load the image.
+
+        Returns:
+            Loaded image as a `GeneratedImage` object.
+        """
+        base_image = Image.load_from_file(location=location)
+        exif = base_image._pil_image.getexif()  # pylint: disable=protected-access
+        exif_comment_dict = json.loads(exif[_EXIF_USER_COMMENT_TAG_IDX])
+        generation_parameters = exif_comment_dict[_IMAGE_GENERATION_PARAMETERS_EXIF_KEY]
+        return GeneratedImage(
+            image_bytes=base_image._image_bytes,  # pylint: disable=protected-access
+            generation_parameters=generation_parameters,
+        )
+
+    def save(self, location: str, include_generation_parameters: bool = True):
+        """Saves image to a file.
+
+        Args:
+            location: Local path where to save the image.
+            include_generation_parameters: Whether to include the image
+                generation parameters in the image's EXIF metadata.
+        """
+        if include_generation_parameters:
+            if not self._generation_parameters:
+                raise ValueError("Image does not have generation parameters.")
+            if not PIL:
+                raise ValueError("The PIL module is required for saving generation parameters.")
+
+            exif = self._pil_image.getexif()
+            exif[_EXIF_USER_COMMENT_TAG_IDX] = json.dumps(
+                {_IMAGE_GENERATION_PARAMETERS_EXIF_KEY: self._generation_parameters}
+            )
+            self._pil_image.save(location, exif=exif)
+        else:
+            super().save(location=location)
+
+
+class Video:
+    """Video."""
+
+    _loaded_bytes: Optional[bytes] = None
+
+    def __init__(
+        self,
+        *,
+        video_bytes: Optional[bytes] = None,
+        mime_type: Optional[str] = None,
+    ):
+        """Creates a `Video` object.
+        Args:
+            video_bytes: Video file bytes. Video can be in AVI, FLV, MKV, MOV,
+                MP4, MPEG, MPG, WEBM, and WMV formats.
+        """
+        self._video_bytes = video_bytes
+        self._mime_type = mime_type
+
+    def _ipython_display_(self):
+        if IPython.display is None:
+            return
+
+        IPython.display.display(
+            IPython.display.Video(data=self._video_bytes, mimetype=self._mime_type, embed=True)
+        )
+
+    @staticmethod
+    def load_from_file(location: str) -> "Video":
+        """Loads video from local file.
+        Args:
+            location: Local path from where to load the video.
+        Returns:
+            Loaded video as an `Video` object.
+        """
+        # Load video from local path
+        video_bytes = pathlib.Path(location).read_bytes()
+        mimetypes.guess_type(location)
+        video = Video(video_bytes=video_bytes, mime_type=mimetypes.guess_type(location))
+        return video
+
+    @property
+    def _video_bytes(self) -> bytes:
+        return self._loaded_bytes
+
+    @_video_bytes.setter
+    def _video_bytes(self, value: bytes):
+        self._loaded_bytes = value
+
+    @property
+    def mime_type(self) -> str:
+        """Returns the MIME type of the video."""
+        return self._mime_type
+
+    def save(self, location: str):
+        """Saves video to a file.
+        Args:
+            location: Local path where to save the video.
+        """
+        pathlib.Path(location).write_bytes(self._video_bytes)
+
+    def _as_base64_string(self) -> str:
+        """Encodes video using the base64 encoding.
+        Returns:
+            Base64 encoding of the video as a string.
+        """
+        # ! b64encode returns `bytes` object, not `str`.
+        # We need to convert `bytes` to `str`, otherwise we get service error:
+        # "received initial metadata size exceeds limit"
+        return base64.b64encode(self._video_bytes).decode("ascii")
+
+
+_thread_local = threading.local()
+_thread_local.http = httplib2.Http()
+
+
+class GeneratedVideo(Video):
+    def __init__(self, *, uri):
+        self._uri = uri
+        self._loaded_bytes = None
+
+    @property
+    def _mime_type(self):
+        return "video/mp4"
+
+    @property
+    def _video_bytes(self) -> bytes:
+        if self._loaded_bytes is None:
+            self._loaded_bytes = self.download()
+        return self._loaded_bytes
+
+    @_video_bytes.setter
+    def _video_bytes(self, value: bytes):
+        self._loaded_bytes = value
+
+    def download(self):
+        api_key = client._client_manager.client_config["client_options"].api_key
+
+        request = googleapiclient.http.HttpRequest(
+            http=_thread_local.http,
+            postproc=googleapiclient.model.MediaModel().response,
+            uri=f"{self._uri}&key={api_key}",
+            method="GET",
+            headers={
+                "accept": "*/*",
+                "accept-encoding": "gzip, deflate",
+                "user-agent": "(gzip)",
+                "x-goog-api-client": "gdcl/2.151.0 gl-python/3.12.7",
+            },
+        )
+        result = request.execute()
+        return result

.venv/lib/python3.11/site-packages/google/generativeai/types/model_types.py

@@ -0,0 +1,390 @@
+# -*- coding: utf-8 -*-
+# Copyright 2023 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.
+"""Type definitions for the models service."""
+from __future__ import annotations
+
+from collections.abc import Mapping
+import csv
+import dataclasses
+import datetime
+import json
+import pathlib
+import re
+
+from typing import Any, Iterable, Union
+
+import urllib.request
+from typing_extensions import TypedDict
+
+from google.generativeai import protos
+from google.generativeai.types import permission_types
+from google.generativeai import string_utils
+
+
+__all__ = [
+    "Model",
+    "ModelNameOptions",
+    "AnyModelNameOptions",
+    "BaseModelNameOptions",
+    "TunedModelNameOptions",
+    "ModelsIterable",
+    "TunedModel",
+    "TunedModelState",
+]
+
+TunedModelState = protos.TunedModel.State
+
+TunedModelStateOptions = Union[None, str, int, TunedModelState]
+
+_TUNED_MODEL_VALID_NAME = r"[a-z](([a-z0-9-]{0,61}[a-z0-9])?)$"
+TUNED_MODEL_NAME_ERROR_MSG = """The `name` must consist of alphanumeric characters (or -) and be at most 63 characters; The name you entered:
+\tlen(name)== {length}
+\tname={name}
+"""
+
+
+def valid_tuned_model_name(name: str) -> bool:
+    return re.match(_TUNED_MODEL_VALID_NAME, name) is not None
+
+
+# fmt: off
+_TUNED_MODEL_STATES: dict[TunedModelStateOptions, TunedModelState] = {
+    TunedModelState.ACTIVE: TunedModelState.ACTIVE,
+    int(TunedModelState.ACTIVE): TunedModelState.ACTIVE,
+    "active": TunedModelState.ACTIVE,
+
+    TunedModelState.CREATING: TunedModelState.CREATING,
+    int(TunedModelState.CREATING): TunedModelState.CREATING,
+    "creating": TunedModelState.CREATING,
+
+    TunedModelState.FAILED: TunedModelState.FAILED,
+    int(TunedModelState.FAILED): TunedModelState.FAILED,
+    "failed": TunedModelState.FAILED,
+
+    TunedModelState.STATE_UNSPECIFIED: TunedModelState.STATE_UNSPECIFIED,
+    int(TunedModelState.STATE_UNSPECIFIED): TunedModelState.STATE_UNSPECIFIED,
+    "state_unspecified": TunedModelState.STATE_UNSPECIFIED,
+    "unspecified": TunedModelState.STATE_UNSPECIFIED,
+    None: TunedModelState.STATE_UNSPECIFIED,
+}
+# fmt: on
+
+
+def to_tuned_model_state(x: TunedModelStateOptions) -> TunedModelState:
+    if isinstance(x, str):
+        x = x.lower()
+    return _TUNED_MODEL_STATES[x]
+
+
+@string_utils.prettyprint
+@dataclasses.dataclass
+class Model:
+    """A dataclass representation of a `protos.Model`.
+
+    Attributes:
+        name: The resource name of the `Model`. Format: `models/{model}` with a `{model}` naming
+           convention of: "{base_model_id}-{version}". For example: `models/chat-bison-001`.
+        base_model_id: The base name of the model. For example: `chat-bison`.
+        version:  The major version number of the model. For example: `001`.
+        display_name: 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: A short description of the model.
+        input_token_limit: Maximum number of input tokens allowed for this model.
+        output_token_limit: Maximum number of output tokens available for this model.
+        supported_generation_methods: lists which methods are supported by the model. The method
+          names are defined as Pascal case strings, such as `generateMessage` which correspond to
+          API methods.
+    """
+
+    name: str
+    base_model_id: str
+    version: str
+    display_name: str
+    description: str
+    input_token_limit: int
+    output_token_limit: int
+    supported_generation_methods: list[str]
+    temperature: float | None = None
+    max_temperature: float | None = None
+    top_p: float | None = None
+    top_k: int | None = None
+
+
+def _fix_microseconds(match):
+    # microseconds needs exactly 6 digits
+    fraction = float(match.group(0))
+    return f".{int(round(fraction*1e6)):06d}"
+
+
+def idecode_time(parent: dict["str", Any], name: str):
+    time = parent.pop(name, None)
+    if time is not None:
+        if "." in time:
+            time = re.sub(r"\.\d+", _fix_microseconds, time)
+            dt = datetime.datetime.strptime(time, "%Y-%m-%dT%H:%M:%S.%fZ")
+        else:
+            dt = datetime.datetime.strptime(time, "%Y-%m-%dT%H:%M:%SZ")
+
+        dt = dt.replace(tzinfo=datetime.timezone.utc)
+        parent[name] = dt
+
+
+def decode_tuned_model(tuned_model: protos.TunedModel | dict["str", Any]) -> TunedModel:
+    if isinstance(tuned_model, protos.TunedModel):
+        tuned_model = type(tuned_model).to_dict(
+            tuned_model, including_default_value_fields=False
+        )  # pytype: disable=attribute-error
+    tuned_model["state"] = to_tuned_model_state(tuned_model.pop("state", None))
+
+    base_model = tuned_model.pop("base_model", None)
+    tuned_model_source = tuned_model.pop("tuned_model_source", None)
+    if base_model is not None:
+        tuned_model["base_model"] = base_model
+        tuned_model["source_model"] = base_model
+    elif tuned_model_source is not None:
+        tuned_model["base_model"] = tuned_model_source["base_model"]
+        tuned_model["source_model"] = tuned_model_source["tuned_model"]
+
+    idecode_time(tuned_model, "create_time")
+    idecode_time(tuned_model, "update_time")
+
+    task = tuned_model.pop("tuning_task", None)
+    if task is not None:
+        hype = task.pop("hyperparameters", None)
+        if hype is not None:
+            hype = Hyperparameters(**hype)
+            task["hyperparameters"] = hype
+
+        idecode_time(task, "start_time")
+        idecode_time(task, "complete_time")
+
+        snapshots = task.pop("snapshots", None)
+        if snapshots is not None:
+            for snap in snapshots:
+                idecode_time(snap, "compute_time")
+            task["snapshots"] = snapshots
+        task = TuningTask(**task)
+        tuned_model["tuning_task"] = task
+    return TunedModel(**tuned_model)
+
+
+@string_utils.prettyprint
+@dataclasses.dataclass
+class TunedModel:
+    """A dataclass representation of a `protos.TunedModel`."""
+
+    name: str | None = None
+    source_model: str | None = None
+    base_model: str | None = None
+    display_name: str = ""
+    description: str = ""
+    temperature: float | None = None
+    top_p: float | None = None
+    top_k: float | None = None
+    state: TunedModelState = TunedModelState.STATE_UNSPECIFIED
+    create_time: datetime.datetime | None = None
+    update_time: datetime.datetime | None = None
+    tuning_task: TuningTask | None = None
+    reader_project_numbers: list[int] | None = None
+
+    @property
+    def permissions(self) -> permission_types.Permissions:
+        return permission_types.Permissions(self)
+
+
+@string_utils.prettyprint
+@dataclasses.dataclass
+class TuningTask:
+    start_time: datetime.datetime | None = None
+    complete_time: datetime.datetime | None = None
+    snapshots: list[TuningSnapshot] = dataclasses.field(default_factory=list)
+    hyperparameters: Hyperparameters | None = None
+
+
+class TuningExampleDict(TypedDict):
+    text_input: str
+    output: str
+
+
+TuningExampleOptions = Union[TuningExampleDict, protos.TuningExample, tuple[str, str], list[str]]
+
+# TODO(markdaoust): gs:// URLS? File-type argument for files without extension?
+TuningDataOptions = Union[
+    pathlib.Path,
+    str,
+    protos.Dataset,
+    Mapping[str, Iterable[str]],
+    Iterable[TuningExampleOptions],
+]
+
+
+def encode_tuning_data(
+    data: TuningDataOptions, input_key="text_input", output_key="output"
+) -> protos.Dataset:
+    if isinstance(data, protos.Dataset):
+        return data
+
+    if isinstance(data, str):
+        # Strings are either URLs or system paths.
+        if re.match(r"^\w+://\S+$", data):
+            data = _normalize_url(data)
+        else:
+            # Normalize system paths to use pathlib
+            data = pathlib.Path(data)
+
+    if isinstance(data, (str, pathlib.Path)):
+        if isinstance(data, str):
+            f = urllib.request.urlopen(data)
+            # csv needs strings, json does not.
+            content = (line.decode("utf-8") for line in f)
+        else:
+            f = data.open("r")
+            content = f
+
+        if str(data).lower().endswith(".json"):
+            with f:
+                data = json.load(f)
+        else:
+            with f:
+                data = csv.DictReader(content)
+                return _convert_iterable(data, input_key, output_key)
+
+    if hasattr(data, "keys"):
+        return _convert_dict(data, input_key, output_key)
+    else:
+        return _convert_iterable(data, input_key, output_key)
+
+
+def _normalize_url(url: str) -> str:
+    sheet_base = "https://docs.google.com/spreadsheets"
+    if url.startswith(sheet_base):
+        # Normalize google-sheets URLs to download the csv.
+        id_match = re.match(f"{sheet_base}/d/[^/]+", url)
+        if id_match is None:
+            raise ValueError("Incomplete Google Sheets URL: {data}")
+
+        if tab_match := re.search(r"gid=(\d+)", url):
+            tab_param = f"&gid={tab_match.group(1)}"
+        else:
+            tab_param = ""
+
+        url = f"{id_match.group(0)}/export?format=csv{tab_param}"
+
+    return url
+
+
+def _convert_dict(data, input_key, output_key):
+    new_data = list()
+
+    try:
+        inputs = data[input_key]
+    except KeyError:
+        raise KeyError(
+            f"Invalid key: The input key '{input_key}' does not exist in the data. "
+            f"Available keys are: {sorted(data.keys())}."
+        )
+
+    try:
+        outputs = data[output_key]
+    except KeyError:
+        raise KeyError(
+            f"Invalid key: The output key '{output_key}' does not exist in the data. "
+            f"Available keys are: {sorted(data.keys())}."
+        )
+
+    for i, o in zip(inputs, outputs):
+        new_data.append(protos.TuningExample({"text_input": str(i), "output": str(o)}))
+    return protos.Dataset(examples=protos.TuningExamples(examples=new_data))
+
+
+def _convert_iterable(data, input_key, output_key):
+    new_data = list()
+    for example in data:
+        example = encode_tuning_example(example, input_key, output_key)
+        new_data.append(example)
+    return protos.Dataset(examples=protos.TuningExamples(examples=new_data))
+
+
+def encode_tuning_example(example: TuningExampleOptions, input_key, output_key):
+    if isinstance(example, protos.TuningExample):
+        return example
+    elif isinstance(example, (tuple, list)):
+        a, b = example
+        example = protos.TuningExample(text_input=a, output=b)
+    else:  # dict
+        example = protos.TuningExample(text_input=example[input_key], output=example[output_key])
+    return example
+
+
+@string_utils.prettyprint
+@dataclasses.dataclass
+class TuningSnapshot:
+    step: int
+    epoch: int
+    mean_score: float
+    compute_time: datetime.datetime
+
+
+@string_utils.prettyprint
+@dataclasses.dataclass
+class Hyperparameters:
+    epoch_count: int = 0
+    batch_size: int = 0
+    learning_rate: float = 0.0
+
+
+BaseModelNameOptions = Union[str, Model, protos.Model]
+TunedModelNameOptions = Union[str, TunedModel, protos.TunedModel]
+AnyModelNameOptions = Union[str, Model, protos.Model, TunedModel, protos.TunedModel]
+ModelNameOptions = AnyModelNameOptions
+
+
+def make_model_name(name: AnyModelNameOptions):
+    if isinstance(name, (Model, protos.Model, TunedModel, protos.TunedModel)):
+        name = name.name  # pytype: disable=attribute-error
+    elif isinstance(name, str):
+        name = name
+    else:
+        raise TypeError(
+            "Invalid input type. Expected one of the following types: `str`, `Model`, or `TunedModel`."
+        )
+
+    if not (name.startswith("models/") or name.startswith("tunedModels/")):
+        raise ValueError(
+            f"Invalid model name: '{name}'. Model names should start with 'models/' or 'tunedModels/'."
+        )
+
+    return name
+
+
+ModelsIterable = Iterable[Model]
+TunedModelsIterable = Iterable[TunedModel]
+
+
+@string_utils.prettyprint
+@dataclasses.dataclass
+class TokenCount:
+    """A dataclass representation of a `protos.TokenCountResponse`.
+
+    Attributes:
+        token_count: The number of tokens returned by the model's tokenizer for the `input_text`.
+        token_count_limit:
+    """
+
+    token_count: int
+    token_count_limit: int
+
+    def over_limit(self):
+        return self.token_count > self.token_count_limit

.venv/lib/python3.11/site-packages/google/generativeai/types/palm_safety_types.py

@@ -0,0 +1,286 @@
+# -*- coding: utf-8 -*-
+# Copyright 2023 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 collections.abc import Mapping
+
+import enum
+import typing
+from typing import Dict, Iterable, List, Union
+
+from typing_extensions import TypedDict
+
+
+from google.generativeai import protos
+from google.generativeai import string_utils
+
+
+__all__ = [
+    "HarmCategory",
+    "HarmProbability",
+    "HarmBlockThreshold",
+    "BlockedReason",
+    "ContentFilterDict",
+    "SafetyRatingDict",
+    "SafetySettingDict",
+    "SafetyFeedbackDict",
+]
+
+# These are basic python enums, it's okay to expose them
+HarmProbability = protos.SafetyRating.HarmProbability
+HarmBlockThreshold = protos.SafetySetting.HarmBlockThreshold
+BlockedReason = protos.ContentFilter.BlockedReason
+
+
+class HarmCategory:
+    """
+    Harm Categories supported by the palm-family models
+    """
+
+    HARM_CATEGORY_UNSPECIFIED = protos.HarmCategory.HARM_CATEGORY_UNSPECIFIED.value
+    HARM_CATEGORY_DEROGATORY = protos.HarmCategory.HARM_CATEGORY_DEROGATORY.value
+    HARM_CATEGORY_TOXICITY = protos.HarmCategory.HARM_CATEGORY_TOXICITY.value
+    HARM_CATEGORY_VIOLENCE = protos.HarmCategory.HARM_CATEGORY_VIOLENCE.value
+    HARM_CATEGORY_SEXUAL = protos.HarmCategory.HARM_CATEGORY_SEXUAL.value
+    HARM_CATEGORY_MEDICAL = protos.HarmCategory.HARM_CATEGORY_MEDICAL.value
+    HARM_CATEGORY_DANGEROUS = protos.HarmCategory.HARM_CATEGORY_DANGEROUS.value
+
+
+HarmCategoryOptions = Union[str, int, HarmCategory]
+
+# fmt: off
+_HARM_CATEGORIES: Dict[HarmCategoryOptions, protos.HarmCategory] = {
+    protos.HarmCategory.HARM_CATEGORY_UNSPECIFIED: protos.HarmCategory.HARM_CATEGORY_UNSPECIFIED,
+    HarmCategory.HARM_CATEGORY_UNSPECIFIED: protos.HarmCategory.HARM_CATEGORY_UNSPECIFIED,
+    0: protos.HarmCategory.HARM_CATEGORY_UNSPECIFIED,
+    "harm_category_unspecified": protos.HarmCategory.HARM_CATEGORY_UNSPECIFIED,
+    "unspecified": protos.HarmCategory.HARM_CATEGORY_UNSPECIFIED,
+
+    protos.HarmCategory.HARM_CATEGORY_DEROGATORY: protos.HarmCategory.HARM_CATEGORY_DEROGATORY,
+    HarmCategory.HARM_CATEGORY_DEROGATORY: protos.HarmCategory.HARM_CATEGORY_DEROGATORY,
+    1: protos.HarmCategory.HARM_CATEGORY_DEROGATORY,
+    "harm_category_derogatory": protos.HarmCategory.HARM_CATEGORY_DEROGATORY,
+    "derogatory": protos.HarmCategory.HARM_CATEGORY_DEROGATORY,
+
+    protos.HarmCategory.HARM_CATEGORY_TOXICITY: protos.HarmCategory.HARM_CATEGORY_TOXICITY,
+    HarmCategory.HARM_CATEGORY_TOXICITY: protos.HarmCategory.HARM_CATEGORY_TOXICITY,
+    2: protos.HarmCategory.HARM_CATEGORY_TOXICITY,
+    "harm_category_toxicity": protos.HarmCategory.HARM_CATEGORY_TOXICITY,
+    "toxicity": protos.HarmCategory.HARM_CATEGORY_TOXICITY,
+    "toxic": protos.HarmCategory.HARM_CATEGORY_TOXICITY,
+
+    protos.HarmCategory.HARM_CATEGORY_VIOLENCE: protos.HarmCategory.HARM_CATEGORY_VIOLENCE,
+    HarmCategory.HARM_CATEGORY_VIOLENCE: protos.HarmCategory.HARM_CATEGORY_VIOLENCE,
+    3: protos.HarmCategory.HARM_CATEGORY_VIOLENCE,
+    "harm_category_violence": protos.HarmCategory.HARM_CATEGORY_VIOLENCE,
+    "violence": protos.HarmCategory.HARM_CATEGORY_VIOLENCE,
+    "violent": protos.HarmCategory.HARM_CATEGORY_VIOLENCE,
+
+    protos.HarmCategory.HARM_CATEGORY_SEXUAL: protos.HarmCategory.HARM_CATEGORY_SEXUAL,
+    HarmCategory.HARM_CATEGORY_SEXUAL: protos.HarmCategory.HARM_CATEGORY_SEXUAL,
+    4: protos.HarmCategory.HARM_CATEGORY_SEXUAL,
+    "harm_category_sexual": protos.HarmCategory.HARM_CATEGORY_SEXUAL,
+    "sexual": protos.HarmCategory.HARM_CATEGORY_SEXUAL,
+    "sex": protos.HarmCategory.HARM_CATEGORY_SEXUAL,
+
+    protos.HarmCategory.HARM_CATEGORY_MEDICAL: protos.HarmCategory.HARM_CATEGORY_MEDICAL,
+    HarmCategory.HARM_CATEGORY_MEDICAL: protos.HarmCategory.HARM_CATEGORY_MEDICAL,
+    5: protos.HarmCategory.HARM_CATEGORY_MEDICAL,
+    "harm_category_medical": protos.HarmCategory.HARM_CATEGORY_MEDICAL,
+    "medical": protos.HarmCategory.HARM_CATEGORY_MEDICAL,
+    "med": protos.HarmCategory.HARM_CATEGORY_MEDICAL,
+
+    protos.HarmCategory.HARM_CATEGORY_DANGEROUS: protos.HarmCategory.HARM_CATEGORY_DANGEROUS,
+    HarmCategory.HARM_CATEGORY_DANGEROUS: protos.HarmCategory.HARM_CATEGORY_DANGEROUS,
+    6: protos.HarmCategory.HARM_CATEGORY_DANGEROUS,
+    "harm_category_dangerous": protos.HarmCategory.HARM_CATEGORY_DANGEROUS,
+    "dangerous": protos.HarmCategory.HARM_CATEGORY_DANGEROUS,
+    "danger": protos.HarmCategory.HARM_CATEGORY_DANGEROUS,
+}
+# fmt: on
+
+
+def to_harm_category(x: HarmCategoryOptions) -> protos.HarmCategory:
+    if isinstance(x, str):
+        x = x.lower()
+    return _HARM_CATEGORIES[x]
+
+
+HarmBlockThresholdOptions = Union[str, int, HarmBlockThreshold]
+
+# fmt: off
+_BLOCK_THRESHOLDS: Dict[HarmBlockThresholdOptions, HarmBlockThreshold] = {
+    HarmBlockThreshold.HARM_BLOCK_THRESHOLD_UNSPECIFIED: HarmBlockThreshold.HARM_BLOCK_THRESHOLD_UNSPECIFIED,
+    0: HarmBlockThreshold.HARM_BLOCK_THRESHOLD_UNSPECIFIED,
+    "harm_block_threshold_unspecified": HarmBlockThreshold.HARM_BLOCK_THRESHOLD_UNSPECIFIED,
+    "block_threshold_unspecified": HarmBlockThreshold.HARM_BLOCK_THRESHOLD_UNSPECIFIED,
+    "unspecified": HarmBlockThreshold.HARM_BLOCK_THRESHOLD_UNSPECIFIED,
+
+    HarmBlockThreshold.BLOCK_LOW_AND_ABOVE: HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
+    1: HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
+    "block_low_and_above": HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
+    "low": HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
+
+    HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
+    2: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
+    "block_medium_and_above": HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
+    "medium": HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
+    "med": HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
+
+    HarmBlockThreshold.BLOCK_ONLY_HIGH: HarmBlockThreshold.BLOCK_ONLY_HIGH,
+    3: HarmBlockThreshold.BLOCK_ONLY_HIGH,
+    "block_only_high": HarmBlockThreshold.BLOCK_ONLY_HIGH,
+    "high": HarmBlockThreshold.BLOCK_ONLY_HIGH,
+
+    HarmBlockThreshold.BLOCK_NONE: HarmBlockThreshold.BLOCK_NONE,
+    4: HarmBlockThreshold.BLOCK_NONE,
+    "block_none": HarmBlockThreshold.BLOCK_NONE,
+}
+# fmt: on
+
+
+def to_block_threshold(x: HarmBlockThresholdOptions) -> HarmBlockThreshold:
+    if isinstance(x, str):
+        x = x.lower()
+    return _BLOCK_THRESHOLDS[x]
+
+
+class ContentFilterDict(TypedDict):
+    reason: BlockedReason
+    message: str
+
+    __doc__ = string_utils.strip_oneof(protos.ContentFilter.__doc__)
+
+
+def convert_filters_to_enums(
+    filters: Iterable[dict],
+) -> List[ContentFilterDict]:
+    result = []
+    for f in filters:
+        f = f.copy()
+        f["reason"] = BlockedReason(f["reason"])
+        f = typing.cast(ContentFilterDict, f)
+        result.append(f)
+    return result
+
+
+class SafetyRatingDict(TypedDict):
+    category: protos.HarmCategory
+    probability: HarmProbability
+
+    __doc__ = string_utils.strip_oneof(protos.SafetyRating.__doc__)
+
+
+def convert_rating_to_enum(rating: dict) -> SafetyRatingDict:
+    return {
+        "category": protos.HarmCategory(rating["category"]),
+        "probability": HarmProbability(rating["probability"]),
+    }
+
+
+def convert_ratings_to_enum(ratings: Iterable[dict]) -> List[SafetyRatingDict]:
+    result = []
+    for r in ratings:
+        result.append(convert_rating_to_enum(r))
+    return result
+
+
+class SafetySettingDict(TypedDict):
+    category: protos.HarmCategory
+    threshold: HarmBlockThreshold
+
+    __doc__ = string_utils.strip_oneof(protos.SafetySetting.__doc__)
+
+
+class LooseSafetySettingDict(TypedDict):
+    category: HarmCategoryOptions
+    threshold: HarmBlockThresholdOptions
+
+
+EasySafetySetting = Mapping[HarmCategoryOptions, HarmBlockThresholdOptions]
+EasySafetySettingDict = dict[HarmCategoryOptions, HarmBlockThresholdOptions]
+
+SafetySettingOptions = Union[EasySafetySetting, Iterable[LooseSafetySettingDict], None]
+
+
+def to_easy_safety_dict(settings: SafetySettingOptions) -> EasySafetySettingDict:
+    if settings is None:
+        return {}
+    elif isinstance(settings, Mapping):
+        return {to_harm_category(key): to_block_threshold(value) for key, value in settings.items()}
+    else:  # Iterable
+        return {
+            to_harm_category(d["category"]): to_block_threshold(d["threshold"]) for d in settings
+        }
+
+
+def normalize_safety_settings(
+    settings: SafetySettingOptions,
+) -> list[SafetySettingDict] | None:
+    if settings is None:
+        return None
+    if isinstance(settings, Mapping):
+        return [
+            {
+                "category": to_harm_category(key),
+                "threshold": to_block_threshold(value),
+            }
+            for key, value in settings.items()
+        ]
+    else:
+        return [
+            {
+                "category": to_harm_category(d["category"]),
+                "threshold": to_block_threshold(d["threshold"]),
+            }
+            for d in settings
+        ]
+
+
+def convert_setting_to_enum(setting: dict) -> SafetySettingDict:
+    return {
+        "category": protos.HarmCategory(setting["category"]),
+        "threshold": HarmBlockThreshold(setting["threshold"]),
+    }
+
+
+class SafetyFeedbackDict(TypedDict):
+    rating: SafetyRatingDict
+    setting: SafetySettingDict
+
+    __doc__ = string_utils.strip_oneof(protos.SafetyFeedback.__doc__)
+
+
+def convert_safety_feedback_to_enums(
+    safety_feedback: Iterable[dict],
+) -> List[SafetyFeedbackDict]:
+    result = []
+    for sf in safety_feedback:
+        result.append(
+            {
+                "rating": convert_rating_to_enum(sf["rating"]),
+                "setting": convert_setting_to_enum(sf["setting"]),
+            }
+        )
+    return result
+
+
+def convert_candidate_enums(candidates):
+    result = []
+    for candidate in candidates:
+        candidate = candidate.copy()
+        candidate["safety_ratings"] = convert_ratings_to_enum(candidate["safety_ratings"])
+        result.append(candidate)
+    return result

.venv/lib/python3.11/site-packages/google/generativeai/types/safety_types.py

@@ -0,0 +1,303 @@
+# -*- coding: utf-8 -*-
+# Copyright 2023 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 collections.abc import Mapping
+
+import enum
+import typing
+from typing import Dict, Iterable, List, Union
+
+from typing_extensions import TypedDict
+
+
+from google.generativeai import protos
+from google.generativeai import string_utils
+
+
+__all__ = [
+    "HarmCategory",
+    "HarmProbability",
+    "HarmBlockThreshold",
+    "BlockedReason",
+    "ContentFilterDict",
+    "SafetyRatingDict",
+    "SafetySettingDict",
+    "SafetyFeedbackDict",
+]
+
+# These are basic python enums, it's okay to expose them
+HarmProbability = protos.SafetyRating.HarmProbability
+HarmBlockThreshold = protos.SafetySetting.HarmBlockThreshold
+BlockedReason = protos.ContentFilter.BlockedReason
+
+import proto
+
+
+class HarmCategory(proto.Enum):
+    """
+    Harm Categories supported by the gemini-family model
+    """
+
+    HARM_CATEGORY_UNSPECIFIED = protos.HarmCategory.HARM_CATEGORY_UNSPECIFIED.value
+    HARM_CATEGORY_HARASSMENT = protos.HarmCategory.HARM_CATEGORY_HARASSMENT.value
+    HARM_CATEGORY_HATE_SPEECH = protos.HarmCategory.HARM_CATEGORY_HATE_SPEECH.value
+    HARM_CATEGORY_SEXUALLY_EXPLICIT = protos.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT.value
+    HARM_CATEGORY_DANGEROUS_CONTENT = protos.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT.value
+
+
+HarmCategoryOptions = Union[str, int, HarmCategory]
+
+# fmt: off
+_HARM_CATEGORIES: Dict[HarmCategoryOptions, protos.HarmCategory] = {
+    protos.HarmCategory.HARM_CATEGORY_UNSPECIFIED: protos.HarmCategory.HARM_CATEGORY_UNSPECIFIED,
+    HarmCategory.HARM_CATEGORY_UNSPECIFIED: protos.HarmCategory.HARM_CATEGORY_UNSPECIFIED,
+    0: protos.HarmCategory.HARM_CATEGORY_UNSPECIFIED,
+    "harm_category_unspecified": protos.HarmCategory.HARM_CATEGORY_UNSPECIFIED,
+    "unspecified": protos.HarmCategory.HARM_CATEGORY_UNSPECIFIED,
+    
+    7: protos.HarmCategory.HARM_CATEGORY_HARASSMENT,
+    protos.HarmCategory.HARM_CATEGORY_HARASSMENT: protos.HarmCategory.HARM_CATEGORY_HARASSMENT,
+    HarmCategory.HARM_CATEGORY_HARASSMENT: protos.HarmCategory.HARM_CATEGORY_HARASSMENT,
+    "harm_category_harassment": protos.HarmCategory.HARM_CATEGORY_HARASSMENT,
+    "harassment": protos.HarmCategory.HARM_CATEGORY_HARASSMENT,
+
+    8: protos.HarmCategory.HARM_CATEGORY_HATE_SPEECH,
+    protos.HarmCategory.HARM_CATEGORY_HATE_SPEECH: protos.HarmCategory.HARM_CATEGORY_HATE_SPEECH,
+    HarmCategory.HARM_CATEGORY_HATE_SPEECH: protos.HarmCategory.HARM_CATEGORY_HATE_SPEECH,
+    'harm_category_hate_speech': protos.HarmCategory.HARM_CATEGORY_HATE_SPEECH,
+    'hate_speech': protos.HarmCategory.HARM_CATEGORY_HATE_SPEECH,
+    'hate': protos.HarmCategory.HARM_CATEGORY_HATE_SPEECH,
+
+    9: protos.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
+    protos.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: protos.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
+    HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: protos.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
+    "harm_category_sexually_explicit": protos.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
+    "harm_category_sexual": protos.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
+    "sexually_explicit": protos.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
+    "sexual": protos.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
+    "sex": protos.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
+
+    10: protos.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
+    protos.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: protos.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
+    HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: protos.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
+    "harm_category_dangerous_content": protos.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
+    "harm_category_dangerous": protos.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
+    "dangerous": protos.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
+    "danger": protos.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
+}
+# fmt: on
+
+
+def to_harm_category(x: HarmCategoryOptions) -> protos.HarmCategory:
+    if isinstance(x, str):
+        x = x.lower()
+    return _HARM_CATEGORIES[x]
+
+
+HarmBlockThresholdOptions = Union[str, int, HarmBlockThreshold]
+
+# fmt: off
+_BLOCK_THRESHOLDS: Dict[HarmBlockThresholdOptions, HarmBlockThreshold] = {
+    HarmBlockThreshold.HARM_BLOCK_THRESHOLD_UNSPECIFIED: HarmBlockThreshold.HARM_BLOCK_THRESHOLD_UNSPECIFIED,
+    0: HarmBlockThreshold.HARM_BLOCK_THRESHOLD_UNSPECIFIED,
+    "harm_block_threshold_unspecified": HarmBlockThreshold.HARM_BLOCK_THRESHOLD_UNSPECIFIED,
+    "block_threshold_unspecified": HarmBlockThreshold.HARM_BLOCK_THRESHOLD_UNSPECIFIED,
+    "unspecified": HarmBlockThreshold.HARM_BLOCK_THRESHOLD_UNSPECIFIED,
+
+    HarmBlockThreshold.BLOCK_LOW_AND_ABOVE: HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
+    1: HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
+    "block_low_and_above": HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
+    "low": HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
+
+    HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
+    2: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
+    "block_medium_and_above": HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
+    "medium": HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
+    "med": HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
+
+    HarmBlockThreshold.BLOCK_ONLY_HIGH: HarmBlockThreshold.BLOCK_ONLY_HIGH,
+    3: HarmBlockThreshold.BLOCK_ONLY_HIGH,
+    "block_only_high": HarmBlockThreshold.BLOCK_ONLY_HIGH,
+    "high": HarmBlockThreshold.BLOCK_ONLY_HIGH,
+
+    HarmBlockThreshold.BLOCK_NONE: HarmBlockThreshold.BLOCK_NONE,
+    4: HarmBlockThreshold.BLOCK_NONE,
+    "block_none": HarmBlockThreshold.BLOCK_NONE,
+}
+# fmt: on
+
+
+def to_block_threshold(x: HarmBlockThresholdOptions) -> HarmBlockThreshold:
+    if isinstance(x, str):
+        x = x.lower()
+    return _BLOCK_THRESHOLDS[x]
+
+
+class ContentFilterDict(TypedDict):
+    reason: BlockedReason
+    message: str
+
+    __doc__ = string_utils.strip_oneof(protos.ContentFilter.__doc__)
+
+
+def convert_filters_to_enums(
+    filters: Iterable[dict],
+) -> List[ContentFilterDict]:
+    result = []
+    for f in filters:
+        f = f.copy()
+        f["reason"] = BlockedReason(f["reason"])
+        f = typing.cast(ContentFilterDict, f)
+        result.append(f)
+    return result
+
+
+class SafetyRatingDict(TypedDict):
+    category: protos.HarmCategory
+    probability: HarmProbability
+
+    __doc__ = string_utils.strip_oneof(protos.SafetyRating.__doc__)
+
+
+def convert_rating_to_enum(rating: dict) -> SafetyRatingDict:
+    return {
+        "category": protos.HarmCategory(rating["category"]),
+        "probability": HarmProbability(rating["probability"]),
+    }
+
+
+def convert_ratings_to_enum(ratings: Iterable[dict]) -> List[SafetyRatingDict]:
+    result = []
+    for r in ratings:
+        result.append(convert_rating_to_enum(r))
+    return result
+
+
+class SafetySettingDict(TypedDict):
+    category: protos.HarmCategory
+    threshold: HarmBlockThreshold
+
+    __doc__ = string_utils.strip_oneof(protos.SafetySetting.__doc__)
+
+
+class LooseSafetySettingDict(TypedDict):
+    category: HarmCategoryOptions
+    threshold: HarmBlockThresholdOptions
+
+
+EasySafetySetting = Mapping[HarmCategoryOptions, HarmBlockThresholdOptions]
+EasySafetySettingDict = dict[HarmCategoryOptions, HarmBlockThresholdOptions]
+
+SafetySettingOptions = Union[
+    HarmBlockThresholdOptions, EasySafetySetting, Iterable[LooseSafetySettingDict], None
+]
+
+
+def _expand_block_threshold(block_threshold: HarmBlockThresholdOptions):
+    block_threshold = to_block_threshold(block_threshold)
+    hc = set(_HARM_CATEGORIES.values())
+    hc.remove(protos.HarmCategory.HARM_CATEGORY_UNSPECIFIED)
+    return {category: block_threshold for category in hc}
+
+
+def to_easy_safety_dict(settings: SafetySettingOptions) -> EasySafetySettingDict:
+    if settings is None:
+        return {}
+
+    if isinstance(settings, (int, str, HarmBlockThreshold)):
+        settings = _expand_block_threshold(settings)
+
+    if isinstance(settings, Mapping):
+        return {to_harm_category(key): to_block_threshold(value) for key, value in settings.items()}
+
+    else:  # Iterable
+        result = {}
+        for setting in settings:
+            if isinstance(setting, protos.SafetySetting):
+                result[to_harm_category(setting.category)] = to_block_threshold(setting.threshold)
+            elif isinstance(setting, dict):
+                result[to_harm_category(setting["category"])] = to_block_threshold(
+                    setting["threshold"]
+                )
+            else:
+                raise ValueError(
+                    f"Could not understand safety setting:\n  {type(setting)=}\n  {setting=}"
+                )
+        return result
+
+
+def normalize_safety_settings(
+    settings: SafetySettingOptions,
+) -> list[SafetySettingDict] | None:
+    if settings is None:
+        return None
+
+    if isinstance(settings, (int, str, HarmBlockThreshold)):
+        settings = _expand_block_threshold(settings)
+
+    if isinstance(settings, Mapping):
+        return [
+            {
+                "category": to_harm_category(key),
+                "threshold": to_block_threshold(value),
+            }
+            for key, value in settings.items()
+        ]
+    else:
+        return [
+            {
+                "category": to_harm_category(d["category"]),
+                "threshold": to_block_threshold(d["threshold"]),
+            }
+            for d in settings
+        ]
+
+
+def convert_setting_to_enum(setting: dict) -> SafetySettingDict:
+    return {
+        "category": protos.HarmCategory(setting["category"]),
+        "threshold": HarmBlockThreshold(setting["threshold"]),
+    }
+
+
+class SafetyFeedbackDict(TypedDict):
+    rating: SafetyRatingDict
+    setting: SafetySettingDict
+
+    __doc__ = string_utils.strip_oneof(protos.SafetyFeedback.__doc__)
+
+
+def convert_safety_feedback_to_enums(
+    safety_feedback: Iterable[dict],
+) -> List[SafetyFeedbackDict]:
+    result = []
+    for sf in safety_feedback:
+        result.append(
+            {
+                "rating": convert_rating_to_enum(sf["rating"]),
+                "setting": convert_setting_to_enum(sf["setting"]),
+            }
+        )
+    return result
+
+
+def convert_candidate_enums(candidates):
+    result = []
+    for candidate in candidates:
+        candidate = candidate.copy()
+        candidate["safety_ratings"] = convert_ratings_to_enum(candidate["safety_ratings"])
+        result.append(candidate)
+    return result

.venv/lib/python3.11/site-packages/google/generativeai/types/text_types.py

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+# Copyright 2023 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
+
+import sys
+import abc
+import dataclasses
+from typing import Any, Dict, List
+from typing_extensions import TypedDict
+
+from google.generativeai import string_utils
+from google.generativeai.types import citation_types
+
+
+class EmbeddingDict(TypedDict):
+    embedding: list[float]
+
+
+class BatchEmbeddingDict(TypedDict):
+    embedding: list[list[float]]

.venv/lib/python3.11/site-packages/google/logging/type/http_request.proto

@@ -0,0 +1,95 @@
+// 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.
+
+syntax = "proto3";
+
+package google.logging.type;
+
+import "google/protobuf/duration.proto";
+
+option csharp_namespace = "Google.Cloud.Logging.Type";
+option go_package = "google.golang.org/genproto/googleapis/logging/type;ltype";
+option java_multiple_files = true;
+option java_outer_classname = "HttpRequestProto";
+option java_package = "com.google.logging.type";
+option php_namespace = "Google\\Cloud\\Logging\\Type";
+option ruby_package = "Google::Cloud::Logging::Type";
+
+// A common proto for logging HTTP requests. Only contains semantics
+// defined by the HTTP specification. Product-specific logging
+// information MUST be defined in a separate message.
+message HttpRequest {
+  // The request method. Examples: `"GET"`, `"HEAD"`, `"PUT"`, `"POST"`.
+  string request_method = 1;
+
+  // The scheme (http, https), the host name, the path and the query
+  // portion of the URL that was requested.
+  // Example: `"http://example.com/some/info?color=red"`.
+  string request_url = 2;
+
+  // The size of the HTTP request message in bytes, including the request
+  // headers and the request body.
+  int64 request_size = 3;
+
+  // The response code indicating the status of response.
+  // Examples: 200, 404.
+  int32 status = 4;
+
+  // The size of the HTTP response message sent back to the client, in bytes,
+  // including the response headers and the response body.
+  int64 response_size = 5;
+
+  // The user agent sent by the client. Example:
+  // `"Mozilla/4.0 (compatible; MSIE 6.0; Windows 98; Q312461; .NET
+  // CLR 1.0.3705)"`.
+  string user_agent = 6;
+
+  // The IP address (IPv4 or IPv6) of the client that issued the HTTP
+  // request. This field can include port information. Examples:
+  // `"192.168.1.1"`, `"10.0.0.1:80"`, `"FE80::0202:B3FF:FE1E:8329"`.
+  string remote_ip = 7;
+
+  // The IP address (IPv4 or IPv6) of the origin server that the request was
+  // sent to. This field can include port information. Examples:
+  // `"192.168.1.1"`, `"10.0.0.1:80"`, `"FE80::0202:B3FF:FE1E:8329"`.
+  string server_ip = 13;
+
+  // The referer URL of the request, as defined in
+  // [HTTP/1.1 Header Field
+  // Definitions](https://datatracker.ietf.org/doc/html/rfc2616#section-14.36).
+  string referer = 8;
+
+  // The request processing latency on the server, from the time the request was
+  // received until the response was sent.
+  google.protobuf.Duration latency = 14;
+
+  // Whether or not a cache lookup was attempted.
+  bool cache_lookup = 11;
+
+  // Whether or not an entity was served from cache
+  // (with or without validation).
+  bool cache_hit = 9;
+
+  // Whether or not the response was validated with the origin server before
+  // being served from cache. This field is only meaningful if `cache_hit` is
+  // True.
+  bool cache_validated_with_origin_server = 10;
+
+  // The number of HTTP response bytes inserted into cache. Set only when a
+  // cache fill was attempted.
+  int64 cache_fill_bytes = 12;
+
+  // Protocol used for the request. Examples: "HTTP/1.1", "HTTP/2", "websocket"
+  string protocol = 15;
+}

.venv/lib/python3.11/site-packages/google/logging/type/log_severity.proto

@@ -0,0 +1,71 @@
+// 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.
+
+syntax = "proto3";
+
+package google.logging.type;
+
+option csharp_namespace = "Google.Cloud.Logging.Type";
+option go_package = "google.golang.org/genproto/googleapis/logging/type;ltype";
+option java_multiple_files = true;
+option java_outer_classname = "LogSeverityProto";
+option java_package = "com.google.logging.type";
+option objc_class_prefix = "GLOG";
+option php_namespace = "Google\\Cloud\\Logging\\Type";
+option ruby_package = "Google::Cloud::Logging::Type";
+
+// The severity of the event described in a log entry, expressed as one of the
+// standard severity levels listed below.  For your reference, the levels are
+// assigned the listed numeric values. The effect of using numeric values other
+// than those listed is undefined.
+//
+// You can filter for log entries by severity.  For example, the following
+// filter expression will match log entries with severities `INFO`, `NOTICE`,
+// and `WARNING`:
+//
+//     severity > DEBUG AND severity <= WARNING
+//
+// If you are writing log entries, you should map other severity encodings to
+// one of these standard levels. For example, you might map all of Java's FINE,
+// FINER, and FINEST levels to `LogSeverity.DEBUG`. You can preserve the
+// original severity level in the log entry payload if you wish.
+enum LogSeverity {
+  // (0) The log entry has no assigned severity level.
+  DEFAULT = 0;
+
+  // (100) Debug or trace information.
+  DEBUG = 100;
+
+  // (200) Routine information, such as ongoing status or performance.
+  INFO = 200;
+
+  // (300) Normal but significant events, such as start up, shut down, or
+  // a configuration change.
+  NOTICE = 300;
+
+  // (400) Warning events might cause problems.
+  WARNING = 400;
+
+  // (500) Error events are likely to cause problems.
+  ERROR = 500;
+
+  // (600) Critical events cause more severe problems or outages.
+  CRITICAL = 600;
+
+  // (700) A person must take an action immediately.
+  ALERT = 700;
+
+  // (800) One or more systems are unusable.
+  EMERGENCY = 800;
+}

.venv/lib/python3.11/site-packages/google/logging/type/log_severity_pb2.py

@@ -0,0 +1,44 @@
+# -*- 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.
+
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: google/logging/type/log_severity.proto
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(
+    b"\n&google/logging/type/log_severity.proto\x12\x13google.logging.type*\x82\x01\n\x0bLogSeverity\x12\x0b\n\x07\x44\x45\x46\x41ULT\x10\x00\x12\t\n\x05\x44\x45\x42UG\x10\x64\x12\t\n\x04INFO\x10\xc8\x01\x12\x0b\n\x06NOTICE\x10\xac\x02\x12\x0c\n\x07WARNING\x10\x90\x03\x12\n\n\x05\x45RROR\x10\xf4\x03\x12\r\n\x08\x43RITICAL\x10\xd8\x04\x12\n\n\x05\x41LERT\x10\xbc\x05\x12\x0e\n\tEMERGENCY\x10\xa0\x06\x42\xc5\x01\n\x17\x63om.google.logging.typeB\x10LogSeverityProtoP\x01Z8google.golang.org/genproto/googleapis/logging/type;ltype\xa2\x02\x04GLOG\xaa\x02\x19Google.Cloud.Logging.Type\xca\x02\x19Google\\Cloud\\Logging\\Type\xea\x02\x1cGoogle::Cloud::Logging::Typeb\x06proto3"
+)
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(
+    DESCRIPTOR, "google.logging.type.log_severity_pb2", _globals
+)
+if _descriptor._USE_C_DESCRIPTORS == False:
+    DESCRIPTOR._options = None
+    DESCRIPTOR._serialized_options = b"\n\027com.google.logging.typeB\020LogSeverityProtoP\001Z8google.golang.org/genproto/googleapis/logging/type;ltype\242\002\004GLOG\252\002\031Google.Cloud.Logging.Type\312\002\031Google\\Cloud\\Logging\\Type\352\002\034Google::Cloud::Logging::Type"
+    _globals["_LOGSEVERITY"]._serialized_start = 64
+    _globals["_LOGSEVERITY"]._serialized_end = 194
+# @@protoc_insertion_point(module_scope)

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

@@ -0,0 +1,10 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+# Copyright 2007 Google Inc. All Rights Reserved.
+
+__version__ = '5.29.3'

.venv/lib/python3.11/site-packages/google/protobuf/any.py

@@ -0,0 +1,39 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+"""Contains the Any helper APIs."""
+
+from typing import Optional
+
+from google.protobuf import descriptor
+from google.protobuf.message import Message
+
+from google.protobuf.any_pb2 import Any
+
+
+def pack(
+    msg: Message,
+    type_url_prefix: Optional[str] = 'type.googleapis.com/',
+    deterministic: Optional[bool] = None,
+) -> Any:
+  any_msg = Any()
+  any_msg.Pack(
+      msg=msg, type_url_prefix=type_url_prefix, deterministic=deterministic
+  )
+  return any_msg
+
+
+def unpack(any_msg: Any, msg: Message) -> bool:
+  return any_msg.Unpack(msg=msg)
+
+
+def type_name(any_msg: Any) -> str:
+  return any_msg.TypeName()
+
+
+def is_type(any_msg: Any, des: descriptor.Descriptor) -> bool:
+  return any_msg.Is(des)

.venv/lib/python3.11/site-packages/google/protobuf/any_pb2.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: google/protobuf/any.proto
+# Protobuf Python Version: 5.29.3
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    5,
+    29,
+    3,
+    '',
+    'google/protobuf/any.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x19google/protobuf/any.proto\x12\x0fgoogle.protobuf\"6\n\x03\x41ny\x12\x19\n\x08type_url\x18\x01 \x01(\tR\x07typeUrl\x12\x14\n\x05value\x18\x02 \x01(\x0cR\x05valueBv\n\x13\x63om.google.protobufB\x08\x41nyProtoP\x01Z,google.golang.org/protobuf/types/known/anypb\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.any_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  _globals['DESCRIPTOR']._loaded_options = None
+  _globals['DESCRIPTOR']._serialized_options = b'\n\023com.google.protobufB\010AnyProtoP\001Z,google.golang.org/protobuf/types/known/anypb\242\002\003GPB\252\002\036Google.Protobuf.WellKnownTypes'
+  _globals['_ANY']._serialized_start=46
+  _globals['_ANY']._serialized_end=100
+# @@protoc_insertion_point(module_scope)

.venv/lib/python3.11/site-packages/google/protobuf/api_pb2.py

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: google/protobuf/api.proto
+# Protobuf Python Version: 5.29.3
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    5,
+    29,
+    3,
+    '',
+    'google/protobuf/api.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from google.protobuf import source_context_pb2 as google_dot_protobuf_dot_source__context__pb2
+from google.protobuf import type_pb2 as google_dot_protobuf_dot_type__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x19google/protobuf/api.proto\x12\x0fgoogle.protobuf\x1a$google/protobuf/source_context.proto\x1a\x1agoogle/protobuf/type.proto\"\xc1\x02\n\x03\x41pi\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x31\n\x07methods\x18\x02 \x03(\x0b\x32\x17.google.protobuf.MethodR\x07methods\x12\x31\n\x07options\x18\x03 \x03(\x0b\x32\x17.google.protobuf.OptionR\x07options\x12\x18\n\x07version\x18\x04 \x01(\tR\x07version\x12\x45\n\x0esource_context\x18\x05 \x01(\x0b\x32\x1e.google.protobuf.SourceContextR\rsourceContext\x12.\n\x06mixins\x18\x06 \x03(\x0b\x32\x16.google.protobuf.MixinR\x06mixins\x12/\n\x06syntax\x18\x07 \x01(\x0e\x32\x17.google.protobuf.SyntaxR\x06syntax\"\xb2\x02\n\x06Method\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12(\n\x10request_type_url\x18\x02 \x01(\tR\x0erequestTypeUrl\x12+\n\x11request_streaming\x18\x03 \x01(\x08R\x10requestStreaming\x12*\n\x11response_type_url\x18\x04 \x01(\tR\x0fresponseTypeUrl\x12-\n\x12response_streaming\x18\x05 \x01(\x08R\x11responseStreaming\x12\x31\n\x07options\x18\x06 \x03(\x0b\x32\x17.google.protobuf.OptionR\x07options\x12/\n\x06syntax\x18\x07 \x01(\x0e\x32\x17.google.protobuf.SyntaxR\x06syntax\"/\n\x05Mixin\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x12\n\x04root\x18\x02 \x01(\tR\x04rootBv\n\x13\x63om.google.protobufB\x08\x41piProtoP\x01Z,google.golang.org/protobuf/types/known/apipb\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.api_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  _globals['DESCRIPTOR']._loaded_options = None
+  _globals['DESCRIPTOR']._serialized_options = b'\n\023com.google.protobufB\010ApiProtoP\001Z,google.golang.org/protobuf/types/known/apipb\242\002\003GPB\252\002\036Google.Protobuf.WellKnownTypes'
+  _globals['_API']._serialized_start=113
+  _globals['_API']._serialized_end=434
+  _globals['_METHOD']._serialized_start=437
+  _globals['_METHOD']._serialized_end=743
+  _globals['_MIXIN']._serialized_start=745
+  _globals['_MIXIN']._serialized_end=792
+# @@protoc_insertion_point(module_scope)

.venv/lib/python3.11/site-packages/google/protobuf/descriptor.py

@@ -0,0 +1,1511 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+"""Descriptors essentially contain exactly the information found in a .proto
+file, in types that make this information accessible in Python.
+"""
+
+__author__ = 'robinson@google.com (Will Robinson)'
+
+import abc
+import binascii
+import os
+import threading
+import warnings
+
+from google.protobuf.internal import api_implementation
+
+_USE_C_DESCRIPTORS = False
+if api_implementation.Type() != 'python':
+  # pylint: disable=protected-access
+  _message = api_implementation._c_module
+  # TODO: Remove this import after fix api_implementation
+  if _message is None:
+    from google.protobuf.pyext import _message
+  _USE_C_DESCRIPTORS = True
+
+
+class Error(Exception):
+  """Base error for this module."""
+
+
+class TypeTransformationError(Error):
+  """Error transforming between python proto type and corresponding C++ type."""
+
+
+if _USE_C_DESCRIPTORS:
+  # This metaclass allows to override the behavior of code like
+  #     isinstance(my_descriptor, FieldDescriptor)
+  # and make it return True when the descriptor is an instance of the extension
+  # type written in C++.
+  class DescriptorMetaclass(type):
+
+    def __instancecheck__(cls, obj):
+      if super(DescriptorMetaclass, cls).__instancecheck__(obj):
+        return True
+      if isinstance(obj, cls._C_DESCRIPTOR_CLASS):
+        return True
+      return False
+else:
+  # The standard metaclass; nothing changes.
+  DescriptorMetaclass = abc.ABCMeta
+
+
+class _Lock(object):
+  """Wrapper class of threading.Lock(), which is allowed by 'with'."""
+
+  def __new__(cls):
+    self = object.__new__(cls)
+    self._lock = threading.Lock()  # pylint: disable=protected-access
+    return self
+
+  def __enter__(self):
+    self._lock.acquire()
+
+  def __exit__(self, exc_type, exc_value, exc_tb):
+    self._lock.release()
+
+
+_lock = threading.Lock()
+
+
+def _Deprecated(name):
+  if _Deprecated.count > 0:
+    _Deprecated.count -= 1
+    warnings.warn(
+        'Call to deprecated create function %s(). Note: Create unlinked '
+        'descriptors is going to go away. Please use get/find descriptors from '
+        'generated code or query the descriptor_pool.'
+        % name,
+        category=DeprecationWarning, stacklevel=3)
+
+# These must match the values in descriptor.proto, but we can't use them
+# directly because we sometimes need to reference them in feature helpers
+# below *during* the build of descriptor.proto.
+_FEATURESET_MESSAGE_ENCODING_DELIMITED = 2
+_FEATURESET_FIELD_PRESENCE_IMPLICIT = 2
+_FEATURESET_FIELD_PRESENCE_LEGACY_REQUIRED = 3
+_FEATURESET_REPEATED_FIELD_ENCODING_PACKED = 1
+_FEATURESET_ENUM_TYPE_CLOSED = 2
+
+# Deprecated warnings will print 100 times at most which should be enough for
+# users to notice and do not cause timeout.
+_Deprecated.count = 100
+
+
+_internal_create_key = object()
+
+
+class DescriptorBase(metaclass=DescriptorMetaclass):
+
+  """Descriptors base class.
+
+  This class is the base of all descriptor classes. It provides common options
+  related functionality.
+
+  Attributes:
+    has_options:  True if the descriptor has non-default options.  Usually it is
+      not necessary to read this -- just call GetOptions() which will happily
+      return the default instance.  However, it's sometimes useful for
+      efficiency, and also useful inside the protobuf implementation to avoid
+      some bootstrapping issues.
+    file (FileDescriptor): Reference to file info.
+  """
+
+  if _USE_C_DESCRIPTORS:
+    # The class, or tuple of classes, that are considered as "virtual
+    # subclasses" of this descriptor class.
+    _C_DESCRIPTOR_CLASS = ()
+
+  def __init__(self, file, options, serialized_options, options_class_name):
+    """Initialize the descriptor given its options message and the name of the
+    class of the options message. The name of the class is required in case
+    the options message is None and has to be created.
+    """
+    self._features = None
+    self.file = file
+    self._options = options
+    self._loaded_options = None
+    self._options_class_name = options_class_name
+    self._serialized_options = serialized_options
+
+    # Does this descriptor have non-default options?
+    self.has_options = (self._options is not None) or (
+        self._serialized_options is not None
+    )
+
+  @property
+  @abc.abstractmethod
+  def _parent(self):
+    pass
+
+  def _InferLegacyFeatures(self, edition, options, features):
+    """Infers features from proto2/proto3 syntax so that editions logic can be used everywhere.
+
+    Args:
+      edition: The edition to infer features for.
+      options: The options for this descriptor that are being processed.
+      features: The feature set object to modify with inferred features.
+    """
+    pass
+
+  def _GetFeatures(self):
+    if not self._features:
+      self._LazyLoadOptions()
+    return self._features
+
+  def _ResolveFeatures(self, edition, raw_options):
+    """Resolves features from the raw options of this descriptor.
+
+    Args:
+      edition: The edition to use for feature defaults.
+      raw_options: The options for this descriptor that are being processed.
+
+    Returns:
+      A fully resolved feature set for making runtime decisions.
+    """
+    # pylint: disable=g-import-not-at-top
+    from google.protobuf import descriptor_pb2
+
+    if self._parent:
+      features = descriptor_pb2.FeatureSet()
+      features.CopyFrom(self._parent._GetFeatures())
+    else:
+      features = self.file.pool._CreateDefaultFeatures(edition)
+    unresolved = descriptor_pb2.FeatureSet()
+    unresolved.CopyFrom(raw_options.features)
+    self._InferLegacyFeatures(edition, raw_options, unresolved)
+    features.MergeFrom(unresolved)
+
+    # Use the feature cache to reduce memory bloat.
+    return self.file.pool._InternFeatures(features)
+
+  def _LazyLoadOptions(self):
+    """Lazily initializes descriptor options towards the end of the build."""
+    if self._loaded_options:
+      return
+
+    # pylint: disable=g-import-not-at-top
+    from google.protobuf import descriptor_pb2
+
+    if not hasattr(descriptor_pb2, self._options_class_name):
+      raise RuntimeError(
+          'Unknown options class name %s!' % self._options_class_name
+      )
+    options_class = getattr(descriptor_pb2, self._options_class_name)
+    features = None
+    edition = self.file._edition
+
+    if not self.has_options:
+      if not self._features:
+        features = self._ResolveFeatures(
+            descriptor_pb2.Edition.Value(edition), options_class()
+        )
+      with _lock:
+        self._loaded_options = options_class()
+        if not self._features:
+          self._features = features
+    else:
+      if not self._serialized_options:
+        options = self._options
+      else:
+        options = _ParseOptions(options_class(), self._serialized_options)
+
+      if not self._features:
+        features = self._ResolveFeatures(
+            descriptor_pb2.Edition.Value(edition), options
+        )
+      with _lock:
+        self._loaded_options = options
+        if not self._features:
+          self._features = features
+        if options.HasField('features'):
+          options.ClearField('features')
+          if not options.SerializeToString():
+            self._loaded_options = options_class()
+            self.has_options = False
+
+  def GetOptions(self):
+    """Retrieves descriptor options.
+
+    Returns:
+      The options set on this descriptor.
+    """
+    if not self._loaded_options:
+      self._LazyLoadOptions()
+    return self._loaded_options
+
+
+class _NestedDescriptorBase(DescriptorBase):
+  """Common class for descriptors that can be nested."""
+
+  def __init__(self, options, options_class_name, name, full_name,
+               file, containing_type, serialized_start=None,
+               serialized_end=None, serialized_options=None):
+    """Constructor.
+
+    Args:
+      options: Protocol message options or None to use default message options.
+      options_class_name (str): The class name of the above options.
+      name (str): Name of this protocol message type.
+      full_name (str): Fully-qualified name of this protocol message type, which
+        will include protocol "package" name and the name of any enclosing
+        types.
+      containing_type: if provided, this is a nested descriptor, with this
+        descriptor as parent, otherwise None.
+      serialized_start: The start index (inclusive) in block in the
+        file.serialized_pb that describes this descriptor.
+      serialized_end: The end index (exclusive) in block in the
+        file.serialized_pb that describes this descriptor.
+      serialized_options: Protocol message serialized options or None.
+    """
+    super(_NestedDescriptorBase, self).__init__(
+        file, options, serialized_options, options_class_name
+    )
+
+    self.name = name
+    # TODO: Add function to calculate full_name instead of having it in
+    #             memory?
+    self.full_name = full_name
+    self.containing_type = containing_type
+
+    self._serialized_start = serialized_start
+    self._serialized_end = serialized_end
+
+  def CopyToProto(self, proto):
+    """Copies this to the matching proto in descriptor_pb2.
+
+    Args:
+      proto: An empty proto instance from descriptor_pb2.
+
+    Raises:
+      Error: If self couldn't be serialized, due to to few constructor
+        arguments.
+    """
+    if (self.file is not None and
+        self._serialized_start is not None and
+        self._serialized_end is not None):
+      proto.ParseFromString(self.file.serialized_pb[
+          self._serialized_start:self._serialized_end])
+    else:
+      raise Error('Descriptor does not contain serialization.')
+
+
+class Descriptor(_NestedDescriptorBase):
+
+  """Descriptor for a protocol message type.
+
+  Attributes:
+      name (str): Name of this protocol message type.
+      full_name (str): Fully-qualified name of this protocol message type,
+          which will include protocol "package" name and the name of any
+          enclosing types.
+      containing_type (Descriptor): Reference to the descriptor of the type
+          containing us, or None if this is top-level.
+      fields (list[FieldDescriptor]): Field descriptors for all fields in
+          this type.
+      fields_by_number (dict(int, FieldDescriptor)): Same
+          :class:`FieldDescriptor` objects as in :attr:`fields`, but indexed
+          by "number" attribute in each FieldDescriptor.
+      fields_by_name (dict(str, FieldDescriptor)): Same
+          :class:`FieldDescriptor` objects as in :attr:`fields`, but indexed by
+          "name" attribute in each :class:`FieldDescriptor`.
+      nested_types (list[Descriptor]): Descriptor references
+          for all protocol message types nested within this one.
+      nested_types_by_name (dict(str, Descriptor)): Same Descriptor
+          objects as in :attr:`nested_types`, but indexed by "name" attribute
+          in each Descriptor.
+      enum_types (list[EnumDescriptor]): :class:`EnumDescriptor` references
+          for all enums contained within this type.
+      enum_types_by_name (dict(str, EnumDescriptor)): Same
+          :class:`EnumDescriptor` objects as in :attr:`enum_types`, but
+          indexed by "name" attribute in each EnumDescriptor.
+      enum_values_by_name (dict(str, EnumValueDescriptor)): Dict mapping
+          from enum value name to :class:`EnumValueDescriptor` for that value.
+      extensions (list[FieldDescriptor]): All extensions defined directly
+          within this message type (NOT within a nested type).
+      extensions_by_name (dict(str, FieldDescriptor)): Same FieldDescriptor
+          objects as :attr:`extensions`, but indexed by "name" attribute of each
+          FieldDescriptor.
+      is_extendable (bool):  Does this type define any extension ranges?
+      oneofs (list[OneofDescriptor]): The list of descriptors for oneof fields
+          in this message.
+      oneofs_by_name (dict(str, OneofDescriptor)): Same objects as in
+          :attr:`oneofs`, but indexed by "name" attribute.
+      file (FileDescriptor): Reference to file descriptor.
+      is_map_entry: If the message type is a map entry.
+
+  """
+
+  if _USE_C_DESCRIPTORS:
+    _C_DESCRIPTOR_CLASS = _message.Descriptor
+
+    def __new__(
+        cls,
+        name=None,
+        full_name=None,
+        filename=None,
+        containing_type=None,
+        fields=None,
+        nested_types=None,
+        enum_types=None,
+        extensions=None,
+        options=None,
+        serialized_options=None,
+        is_extendable=True,
+        extension_ranges=None,
+        oneofs=None,
+        file=None,  # pylint: disable=redefined-builtin
+        serialized_start=None,
+        serialized_end=None,
+        syntax=None,
+        is_map_entry=False,
+        create_key=None):
+      _message.Message._CheckCalledFromGeneratedFile()
+      return _message.default_pool.FindMessageTypeByName(full_name)
+
+  # NOTE: The file argument redefining a builtin is nothing we can
+  # fix right now since we don't know how many clients already rely on the
+  # name of the argument.
+  def __init__(self, name, full_name, filename, containing_type, fields,
+               nested_types, enum_types, extensions, options=None,
+               serialized_options=None,
+               is_extendable=True, extension_ranges=None, oneofs=None,
+               file=None, serialized_start=None, serialized_end=None,  # pylint: disable=redefined-builtin
+               syntax=None, is_map_entry=False, create_key=None):
+    """Arguments to __init__() are as described in the description
+    of Descriptor fields above.
+
+    Note that filename is an obsolete argument, that is not used anymore.
+    Please use file.name to access this as an attribute.
+    """
+    if create_key is not _internal_create_key:
+      _Deprecated('Descriptor')
+
+    super(Descriptor, self).__init__(
+        options, 'MessageOptions', name, full_name, file,
+        containing_type, serialized_start=serialized_start,
+        serialized_end=serialized_end, serialized_options=serialized_options)
+
+    # We have fields in addition to fields_by_name and fields_by_number,
+    # so that:
+    #   1. Clients can index fields by "order in which they're listed."
+    #   2. Clients can easily iterate over all fields with the terse
+    #      syntax: for f in descriptor.fields: ...
+    self.fields = fields
+    for field in self.fields:
+      field.containing_type = self
+      field.file = file
+    self.fields_by_number = dict((f.number, f) for f in fields)
+    self.fields_by_name = dict((f.name, f) for f in fields)
+    self._fields_by_camelcase_name = None
+
+    self.nested_types = nested_types
+    for nested_type in nested_types:
+      nested_type.containing_type = self
+    self.nested_types_by_name = dict((t.name, t) for t in nested_types)
+
+    self.enum_types = enum_types
+    for enum_type in self.enum_types:
+      enum_type.containing_type = self
+    self.enum_types_by_name = dict((t.name, t) for t in enum_types)
+    self.enum_values_by_name = dict(
+        (v.name, v) for t in enum_types for v in t.values)
+
+    self.extensions = extensions
+    for extension in self.extensions:
+      extension.extension_scope = self
+    self.extensions_by_name = dict((f.name, f) for f in extensions)
+    self.is_extendable = is_extendable
+    self.extension_ranges = extension_ranges
+    self.oneofs = oneofs if oneofs is not None else []
+    self.oneofs_by_name = dict((o.name, o) for o in self.oneofs)
+    for oneof in self.oneofs:
+      oneof.containing_type = self
+      oneof.file = file
+    self._is_map_entry = is_map_entry
+
+  @property
+  def _parent(self):
+    return self.containing_type or self.file
+
+  @property
+  def fields_by_camelcase_name(self):
+    """Same FieldDescriptor objects as in :attr:`fields`, but indexed by
+    :attr:`FieldDescriptor.camelcase_name`.
+    """
+    if self._fields_by_camelcase_name is None:
+      self._fields_by_camelcase_name = dict(
+          (f.camelcase_name, f) for f in self.fields)
+    return self._fields_by_camelcase_name
+
+  def EnumValueName(self, enum, value):
+    """Returns the string name of an enum value.
+
+    This is just a small helper method to simplify a common operation.
+
+    Args:
+      enum: string name of the Enum.
+      value: int, value of the enum.
+
+    Returns:
+      string name of the enum value.
+
+    Raises:
+      KeyError if either the Enum doesn't exist or the value is not a valid
+        value for the enum.
+    """
+    return self.enum_types_by_name[enum].values_by_number[value].name
+
+  def CopyToProto(self, proto):
+    """Copies this to a descriptor_pb2.DescriptorProto.
+
+    Args:
+      proto: An empty descriptor_pb2.DescriptorProto.
+    """
+    # This function is overridden to give a better doc comment.
+    super(Descriptor, self).CopyToProto(proto)
+
+
+# TODO: We should have aggressive checking here,
+# for example:
+#   * If you specify a repeated field, you should not be allowed
+#     to specify a default value.
+#   * [Other examples here as needed].
+#
+# TODO: for this and other *Descriptor classes, we
+# might also want to lock things down aggressively (e.g.,
+# prevent clients from setting the attributes).  Having
+# stronger invariants here in general will reduce the number
+# of runtime checks we must do in reflection.py...
+class FieldDescriptor(DescriptorBase):
+
+  """Descriptor for a single field in a .proto file.
+
+  Attributes:
+    name (str): Name of this field, exactly as it appears in .proto.
+    full_name (str): Name of this field, including containing scope.  This is
+      particularly relevant for extensions.
+    index (int): Dense, 0-indexed index giving the order that this
+      field textually appears within its message in the .proto file.
+    number (int): Tag number declared for this field in the .proto file.
+
+    type (int): (One of the TYPE_* constants below) Declared type.
+    cpp_type (int): (One of the CPPTYPE_* constants below) C++ type used to
+      represent this field.
+
+    label (int): (One of the LABEL_* constants below) Tells whether this
+      field is optional, required, or repeated.
+    has_default_value (bool): True if this field has a default value defined,
+      otherwise false.
+    default_value (Varies): Default value of this field.  Only
+      meaningful for non-repeated scalar fields.  Repeated fields
+      should always set this to [], and non-repeated composite
+      fields should always set this to None.
+
+    containing_type (Descriptor): Descriptor of the protocol message
+      type that contains this field.  Set by the Descriptor constructor
+      if we're passed into one.
+      Somewhat confusingly, for extension fields, this is the
+      descriptor of the EXTENDED message, not the descriptor
+      of the message containing this field.  (See is_extension and
+      extension_scope below).
+    message_type (Descriptor): If a composite field, a descriptor
+      of the message type contained in this field.  Otherwise, this is None.
+    enum_type (EnumDescriptor): If this field contains an enum, a
+      descriptor of that enum.  Otherwise, this is None.
+
+    is_extension: True iff this describes an extension field.
+    extension_scope (Descriptor): Only meaningful if is_extension is True.
+      Gives the message that immediately contains this extension field.
+      Will be None iff we're a top-level (file-level) extension field.
+
+    options (descriptor_pb2.FieldOptions): Protocol message field options or
+      None to use default field options.
+
+    containing_oneof (OneofDescriptor): If the field is a member of a oneof
+      union, contains its descriptor. Otherwise, None.
+
+    file (FileDescriptor): Reference to file descriptor.
+  """
+
+  # Must be consistent with C++ FieldDescriptor::Type enum in
+  # descriptor.h.
+  #
+  # TODO: Find a way to eliminate this repetition.
+  TYPE_DOUBLE         = 1
+  TYPE_FLOAT          = 2
+  TYPE_INT64          = 3
+  TYPE_UINT64         = 4
+  TYPE_INT32          = 5
+  TYPE_FIXED64        = 6
+  TYPE_FIXED32        = 7
+  TYPE_BOOL           = 8
+  TYPE_STRING         = 9
+  TYPE_GROUP          = 10
+  TYPE_MESSAGE        = 11
+  TYPE_BYTES          = 12
+  TYPE_UINT32         = 13
+  TYPE_ENUM           = 14
+  TYPE_SFIXED32       = 15
+  TYPE_SFIXED64       = 16
+  TYPE_SINT32         = 17
+  TYPE_SINT64         = 18
+  MAX_TYPE            = 18
+
+  # Must be consistent with C++ FieldDescriptor::CppType enum in
+  # descriptor.h.
+  #
+  # TODO: Find a way to eliminate this repetition.
+  CPPTYPE_INT32       = 1
+  CPPTYPE_INT64       = 2
+  CPPTYPE_UINT32      = 3
+  CPPTYPE_UINT64      = 4
+  CPPTYPE_DOUBLE      = 5
+  CPPTYPE_FLOAT       = 6
+  CPPTYPE_BOOL        = 7
+  CPPTYPE_ENUM        = 8
+  CPPTYPE_STRING      = 9
+  CPPTYPE_MESSAGE     = 10
+  MAX_CPPTYPE         = 10
+
+  _PYTHON_TO_CPP_PROTO_TYPE_MAP = {
+      TYPE_DOUBLE: CPPTYPE_DOUBLE,
+      TYPE_FLOAT: CPPTYPE_FLOAT,
+      TYPE_ENUM: CPPTYPE_ENUM,
+      TYPE_INT64: CPPTYPE_INT64,
+      TYPE_SINT64: CPPTYPE_INT64,
+      TYPE_SFIXED64: CPPTYPE_INT64,
+      TYPE_UINT64: CPPTYPE_UINT64,
+      TYPE_FIXED64: CPPTYPE_UINT64,
+      TYPE_INT32: CPPTYPE_INT32,
+      TYPE_SFIXED32: CPPTYPE_INT32,
+      TYPE_SINT32: CPPTYPE_INT32,
+      TYPE_UINT32: CPPTYPE_UINT32,
+      TYPE_FIXED32: CPPTYPE_UINT32,
+      TYPE_BYTES: CPPTYPE_STRING,
+      TYPE_STRING: CPPTYPE_STRING,
+      TYPE_BOOL: CPPTYPE_BOOL,
+      TYPE_MESSAGE: CPPTYPE_MESSAGE,
+      TYPE_GROUP: CPPTYPE_MESSAGE
+      }
+
+  # Must be consistent with C++ FieldDescriptor::Label enum in
+  # descriptor.h.
+  #
+  # TODO: Find a way to eliminate this repetition.
+  LABEL_OPTIONAL      = 1
+  LABEL_REQUIRED      = 2
+  LABEL_REPEATED      = 3
+  MAX_LABEL           = 3
+
+  # Must be consistent with C++ constants kMaxNumber, kFirstReservedNumber,
+  # and kLastReservedNumber in descriptor.h
+  MAX_FIELD_NUMBER = (1 << 29) - 1
+  FIRST_RESERVED_FIELD_NUMBER = 19000
+  LAST_RESERVED_FIELD_NUMBER = 19999
+
+  if _USE_C_DESCRIPTORS:
+    _C_DESCRIPTOR_CLASS = _message.FieldDescriptor
+
+    def __new__(cls, name, full_name, index, number, type, cpp_type, label,
+                default_value, message_type, enum_type, containing_type,
+                is_extension, extension_scope, options=None,
+                serialized_options=None,
+                has_default_value=True, containing_oneof=None, json_name=None,
+                file=None, create_key=None):  # pylint: disable=redefined-builtin
+      _message.Message._CheckCalledFromGeneratedFile()
+      if is_extension:
+        return _message.default_pool.FindExtensionByName(full_name)
+      else:
+        return _message.default_pool.FindFieldByName(full_name)
+
+  def __init__(self, name, full_name, index, number, type, cpp_type, label,
+               default_value, message_type, enum_type, containing_type,
+               is_extension, extension_scope, options=None,
+               serialized_options=None,
+               has_default_value=True, containing_oneof=None, json_name=None,
+               file=None, create_key=None):  # pylint: disable=redefined-builtin
+    """The arguments are as described in the description of FieldDescriptor
+    attributes above.
+
+    Note that containing_type may be None, and may be set later if necessary
+    (to deal with circular references between message types, for example).
+    Likewise for extension_scope.
+    """
+    if create_key is not _internal_create_key:
+      _Deprecated('FieldDescriptor')
+
+    super(FieldDescriptor, self).__init__(
+        file, options, serialized_options, 'FieldOptions'
+    )
+    self.name = name
+    self.full_name = full_name
+    self._camelcase_name = None
+    if json_name is None:
+      self.json_name = _ToJsonName(name)
+    else:
+      self.json_name = json_name
+    self.index = index
+    self.number = number
+    self._type = type
+    self.cpp_type = cpp_type
+    self._label = label
+    self.has_default_value = has_default_value
+    self.default_value = default_value
+    self.containing_type = containing_type
+    self.message_type = message_type
+    self.enum_type = enum_type
+    self.is_extension = is_extension
+    self.extension_scope = extension_scope
+    self.containing_oneof = containing_oneof
+    if api_implementation.Type() == 'python':
+      self._cdescriptor = None
+    else:
+      if is_extension:
+        self._cdescriptor = _message.default_pool.FindExtensionByName(full_name)
+      else:
+        self._cdescriptor = _message.default_pool.FindFieldByName(full_name)
+
+  @property
+  def _parent(self):
+    if self.containing_oneof:
+      return self.containing_oneof
+    if self.is_extension:
+      return self.extension_scope or self.file
+    return self.containing_type
+
+  def _InferLegacyFeatures(self, edition, options, features):
+    # pylint: disable=g-import-not-at-top
+    from google.protobuf import descriptor_pb2
+
+    if edition >= descriptor_pb2.Edition.EDITION_2023:
+      return
+
+    if self._label == FieldDescriptor.LABEL_REQUIRED:
+      features.field_presence = (
+          descriptor_pb2.FeatureSet.FieldPresence.LEGACY_REQUIRED
+      )
+
+    if self._type == FieldDescriptor.TYPE_GROUP:
+      features.message_encoding = (
+          descriptor_pb2.FeatureSet.MessageEncoding.DELIMITED
+      )
+
+    if options.HasField('packed'):
+      features.repeated_field_encoding = (
+          descriptor_pb2.FeatureSet.RepeatedFieldEncoding.PACKED
+          if options.packed
+          else descriptor_pb2.FeatureSet.RepeatedFieldEncoding.EXPANDED
+      )
+
+  @property
+  def type(self):
+    if (
+        self._GetFeatures().message_encoding
+        == _FEATURESET_MESSAGE_ENCODING_DELIMITED
+        and self.message_type
+        and not self.message_type.GetOptions().map_entry
+        and not self.containing_type.GetOptions().map_entry
+    ):
+      return FieldDescriptor.TYPE_GROUP
+    return self._type
+
+  @type.setter
+  def type(self, val):
+    self._type = val
+
+  @property
+  def label(self):
+    if (
+        self._GetFeatures().field_presence
+        == _FEATURESET_FIELD_PRESENCE_LEGACY_REQUIRED
+    ):
+      return FieldDescriptor.LABEL_REQUIRED
+    return self._label
+
+  @property
+  def camelcase_name(self):
+    """Camelcase name of this field.
+
+    Returns:
+      str: the name in CamelCase.
+    """
+    if self._camelcase_name is None:
+      self._camelcase_name = _ToCamelCase(self.name)
+    return self._camelcase_name
+
+  @property
+  def has_presence(self):
+    """Whether the field distinguishes between unpopulated and default values.
+
+    Raises:
+      RuntimeError: singular field that is not linked with message nor file.
+    """
+    if self.label == FieldDescriptor.LABEL_REPEATED:
+      return False
+    if (
+        self.cpp_type == FieldDescriptor.CPPTYPE_MESSAGE
+        or self.is_extension
+        or self.containing_oneof
+    ):
+      return True
+
+    return (
+        self._GetFeatures().field_presence
+        != _FEATURESET_FIELD_PRESENCE_IMPLICIT
+    )
+
+  @property
+  def is_packed(self):
+    """Returns if the field is packed."""
+    if self.label != FieldDescriptor.LABEL_REPEATED:
+      return False
+    field_type = self.type
+    if (field_type == FieldDescriptor.TYPE_STRING or
+        field_type == FieldDescriptor.TYPE_GROUP or
+        field_type == FieldDescriptor.TYPE_MESSAGE or
+        field_type == FieldDescriptor.TYPE_BYTES):
+      return False
+
+    return (
+        self._GetFeatures().repeated_field_encoding
+        == _FEATURESET_REPEATED_FIELD_ENCODING_PACKED
+    )
+
+  @staticmethod
+  def ProtoTypeToCppProtoType(proto_type):
+    """Converts from a Python proto type to a C++ Proto Type.
+
+    The Python ProtocolBuffer classes specify both the 'Python' datatype and the
+    'C++' datatype - and they're not the same. This helper method should
+    translate from one to another.
+
+    Args:
+      proto_type: the Python proto type (descriptor.FieldDescriptor.TYPE_*)
+    Returns:
+      int: descriptor.FieldDescriptor.CPPTYPE_*, the C++ type.
+    Raises:
+      TypeTransformationError: when the Python proto type isn't known.
+    """
+    try:
+      return FieldDescriptor._PYTHON_TO_CPP_PROTO_TYPE_MAP[proto_type]
+    except KeyError:
+      raise TypeTransformationError('Unknown proto_type: %s' % proto_type)
+
+
+class EnumDescriptor(_NestedDescriptorBase):
+
+  """Descriptor for an enum defined in a .proto file.
+
+  Attributes:
+    name (str): Name of the enum type.
+    full_name (str): Full name of the type, including package name
+      and any enclosing type(s).
+
+    values (list[EnumValueDescriptor]): List of the values
+      in this enum.
+    values_by_name (dict(str, EnumValueDescriptor)): Same as :attr:`values`,
+      but indexed by the "name" field of each EnumValueDescriptor.
+    values_by_number (dict(int, EnumValueDescriptor)): Same as :attr:`values`,
+      but indexed by the "number" field of each EnumValueDescriptor.
+    containing_type (Descriptor): Descriptor of the immediate containing
+      type of this enum, or None if this is an enum defined at the
+      top level in a .proto file.  Set by Descriptor's constructor
+      if we're passed into one.
+    file (FileDescriptor): Reference to file descriptor.
+    options (descriptor_pb2.EnumOptions): Enum options message or
+      None to use default enum options.
+  """
+
+  if _USE_C_DESCRIPTORS:
+    _C_DESCRIPTOR_CLASS = _message.EnumDescriptor
+
+    def __new__(cls, name, full_name, filename, values,
+                containing_type=None, options=None,
+                serialized_options=None, file=None,  # pylint: disable=redefined-builtin
+                serialized_start=None, serialized_end=None, create_key=None):
+      _message.Message._CheckCalledFromGeneratedFile()
+      return _message.default_pool.FindEnumTypeByName(full_name)
+
+  def __init__(self, name, full_name, filename, values,
+               containing_type=None, options=None,
+               serialized_options=None, file=None,  # pylint: disable=redefined-builtin
+               serialized_start=None, serialized_end=None, create_key=None):
+    """Arguments are as described in the attribute description above.
+
+    Note that filename is an obsolete argument, that is not used anymore.
+    Please use file.name to access this as an attribute.
+    """
+    if create_key is not _internal_create_key:
+      _Deprecated('EnumDescriptor')
+
+    super(EnumDescriptor, self).__init__(
+        options, 'EnumOptions', name, full_name, file,
+        containing_type, serialized_start=serialized_start,
+        serialized_end=serialized_end, serialized_options=serialized_options)
+
+    self.values = values
+    for value in self.values:
+      value.file = file
+      value.type = self
+    self.values_by_name = dict((v.name, v) for v in values)
+    # Values are reversed to ensure that the first alias is retained.
+    self.values_by_number = dict((v.number, v) for v in reversed(values))
+
+  @property
+  def _parent(self):
+    return self.containing_type or self.file
+
+  @property
+  def is_closed(self):
+    """Returns true whether this is a "closed" enum.
+
+    This means that it:
+    - Has a fixed set of values, rather than being equivalent to an int32.
+    - Encountering values not in this set causes them to be treated as unknown
+      fields.
+    - The first value (i.e., the default) may be nonzero.
+
+    WARNING: Some runtimes currently have a quirk where non-closed enums are
+    treated as closed when used as the type of fields defined in a
+    `syntax = proto2;` file. This quirk is not present in all runtimes; as of
+    writing, we know that:
+
+    - C++, Java, and C++-based Python share this quirk.
+    - UPB and UPB-based Python do not.
+    - PHP and Ruby treat all enums as open regardless of declaration.
+
+    Care should be taken when using this function to respect the target
+    runtime's enum handling quirks.
+    """
+    return self._GetFeatures().enum_type == _FEATURESET_ENUM_TYPE_CLOSED
+
+  def CopyToProto(self, proto):
+    """Copies this to a descriptor_pb2.EnumDescriptorProto.
+
+    Args:
+      proto (descriptor_pb2.EnumDescriptorProto): An empty descriptor proto.
+    """
+    # This function is overridden to give a better doc comment.
+    super(EnumDescriptor, self).CopyToProto(proto)
+
+
+class EnumValueDescriptor(DescriptorBase):
+
+  """Descriptor for a single value within an enum.
+
+  Attributes:
+    name (str): Name of this value.
+    index (int): Dense, 0-indexed index giving the order that this
+      value appears textually within its enum in the .proto file.
+    number (int): Actual number assigned to this enum value.
+    type (EnumDescriptor): :class:`EnumDescriptor` to which this value
+      belongs.  Set by :class:`EnumDescriptor`'s constructor if we're
+      passed into one.
+    options (descriptor_pb2.EnumValueOptions): Enum value options message or
+      None to use default enum value options options.
+  """
+
+  if _USE_C_DESCRIPTORS:
+    _C_DESCRIPTOR_CLASS = _message.EnumValueDescriptor
+
+    def __new__(cls, name, index, number,
+                type=None,  # pylint: disable=redefined-builtin
+                options=None, serialized_options=None, create_key=None):
+      _message.Message._CheckCalledFromGeneratedFile()
+      # There is no way we can build a complete EnumValueDescriptor with the
+      # given parameters (the name of the Enum is not known, for example).
+      # Fortunately generated files just pass it to the EnumDescriptor()
+      # constructor, which will ignore it, so returning None is good enough.
+      return None
+
+  def __init__(self, name, index, number,
+               type=None,  # pylint: disable=redefined-builtin
+               options=None, serialized_options=None, create_key=None):
+    """Arguments are as described in the attribute description above."""
+    if create_key is not _internal_create_key:
+      _Deprecated('EnumValueDescriptor')
+
+    super(EnumValueDescriptor, self).__init__(
+        type.file if type else None,
+        options,
+        serialized_options,
+        'EnumValueOptions',
+    )
+    self.name = name
+    self.index = index
+    self.number = number
+    self.type = type
+
+  @property
+  def _parent(self):
+    return self.type
+
+
+class OneofDescriptor(DescriptorBase):
+  """Descriptor for a oneof field.
+
+  Attributes:
+    name (str): Name of the oneof field.
+    full_name (str): Full name of the oneof field, including package name.
+    index (int): 0-based index giving the order of the oneof field inside
+      its containing type.
+    containing_type (Descriptor): :class:`Descriptor` of the protocol message
+      type that contains this field.  Set by the :class:`Descriptor` constructor
+      if we're passed into one.
+    fields (list[FieldDescriptor]): The list of field descriptors this
+      oneof can contain.
+  """
+
+  if _USE_C_DESCRIPTORS:
+    _C_DESCRIPTOR_CLASS = _message.OneofDescriptor
+
+    def __new__(
+        cls, name, full_name, index, containing_type, fields, options=None,
+        serialized_options=None, create_key=None):
+      _message.Message._CheckCalledFromGeneratedFile()
+      return _message.default_pool.FindOneofByName(full_name)
+
+  def __init__(
+      self, name, full_name, index, containing_type, fields, options=None,
+      serialized_options=None, create_key=None):
+    """Arguments are as described in the attribute description above."""
+    if create_key is not _internal_create_key:
+      _Deprecated('OneofDescriptor')
+
+    super(OneofDescriptor, self).__init__(
+        containing_type.file if containing_type else None,
+        options,
+        serialized_options,
+        'OneofOptions',
+    )
+    self.name = name
+    self.full_name = full_name
+    self.index = index
+    self.containing_type = containing_type
+    self.fields = fields
+
+  @property
+  def _parent(self):
+    return self.containing_type
+
+
+class ServiceDescriptor(_NestedDescriptorBase):
+
+  """Descriptor for a service.
+
+  Attributes:
+    name (str): Name of the service.
+    full_name (str): Full name of the service, including package name.
+    index (int): 0-indexed index giving the order that this services
+      definition appears within the .proto file.
+    methods (list[MethodDescriptor]): List of methods provided by this
+      service.
+    methods_by_name (dict(str, MethodDescriptor)): Same
+      :class:`MethodDescriptor` objects as in :attr:`methods_by_name`, but
+      indexed by "name" attribute in each :class:`MethodDescriptor`.
+    options (descriptor_pb2.ServiceOptions): Service options message or
+      None to use default service options.
+    file (FileDescriptor): Reference to file info.
+  """
+
+  if _USE_C_DESCRIPTORS:
+    _C_DESCRIPTOR_CLASS = _message.ServiceDescriptor
+
+    def __new__(
+        cls,
+        name=None,
+        full_name=None,
+        index=None,
+        methods=None,
+        options=None,
+        serialized_options=None,
+        file=None,  # pylint: disable=redefined-builtin
+        serialized_start=None,
+        serialized_end=None,
+        create_key=None):
+      _message.Message._CheckCalledFromGeneratedFile()  # pylint: disable=protected-access
+      return _message.default_pool.FindServiceByName(full_name)
+
+  def __init__(self, name, full_name, index, methods, options=None,
+               serialized_options=None, file=None,  # pylint: disable=redefined-builtin
+               serialized_start=None, serialized_end=None, create_key=None):
+    if create_key is not _internal_create_key:
+      _Deprecated('ServiceDescriptor')
+
+    super(ServiceDescriptor, self).__init__(
+        options, 'ServiceOptions', name, full_name, file,
+        None, serialized_start=serialized_start,
+        serialized_end=serialized_end, serialized_options=serialized_options)
+    self.index = index
+    self.methods = methods
+    self.methods_by_name = dict((m.name, m) for m in methods)
+    # Set the containing service for each method in this service.
+    for method in self.methods:
+      method.file = self.file
+      method.containing_service = self
+
+  @property
+  def _parent(self):
+    return self.file
+
+  def FindMethodByName(self, name):
+    """Searches for the specified method, and returns its descriptor.
+
+    Args:
+      name (str): Name of the method.
+
+    Returns:
+      MethodDescriptor: The descriptor for the requested method.
+
+    Raises:
+      KeyError: if the method cannot be found in the service.
+    """
+    return self.methods_by_name[name]
+
+  def CopyToProto(self, proto):
+    """Copies this to a descriptor_pb2.ServiceDescriptorProto.
+
+    Args:
+      proto (descriptor_pb2.ServiceDescriptorProto): An empty descriptor proto.
+    """
+    # This function is overridden to give a better doc comment.
+    super(ServiceDescriptor, self).CopyToProto(proto)
+
+
+class MethodDescriptor(DescriptorBase):
+
+  """Descriptor for a method in a service.
+
+  Attributes:
+    name (str): Name of the method within the service.
+    full_name (str): Full name of method.
+    index (int): 0-indexed index of the method inside the service.
+    containing_service (ServiceDescriptor): The service that contains this
+      method.
+    input_type (Descriptor): The descriptor of the message that this method
+      accepts.
+    output_type (Descriptor): The descriptor of the message that this method
+      returns.
+    client_streaming (bool): Whether this method uses client streaming.
+    server_streaming (bool): Whether this method uses server streaming.
+    options (descriptor_pb2.MethodOptions or None): Method options message, or
+      None to use default method options.
+  """
+
+  if _USE_C_DESCRIPTORS:
+    _C_DESCRIPTOR_CLASS = _message.MethodDescriptor
+
+    def __new__(cls,
+                name,
+                full_name,
+                index,
+                containing_service,
+                input_type,
+                output_type,
+                client_streaming=False,
+                server_streaming=False,
+                options=None,
+                serialized_options=None,
+                create_key=None):
+      _message.Message._CheckCalledFromGeneratedFile()  # pylint: disable=protected-access
+      return _message.default_pool.FindMethodByName(full_name)
+
+  def __init__(self,
+               name,
+               full_name,
+               index,
+               containing_service,
+               input_type,
+               output_type,
+               client_streaming=False,
+               server_streaming=False,
+               options=None,
+               serialized_options=None,
+               create_key=None):
+    """The arguments are as described in the description of MethodDescriptor
+    attributes above.
+
+    Note that containing_service may be None, and may be set later if necessary.
+    """
+    if create_key is not _internal_create_key:
+      _Deprecated('MethodDescriptor')
+
+    super(MethodDescriptor, self).__init__(
+        containing_service.file if containing_service else None,
+        options,
+        serialized_options,
+        'MethodOptions',
+    )
+    self.name = name
+    self.full_name = full_name
+    self.index = index
+    self.containing_service = containing_service
+    self.input_type = input_type
+    self.output_type = output_type
+    self.client_streaming = client_streaming
+    self.server_streaming = server_streaming
+
+  @property
+  def _parent(self):
+    return self.containing_service
+
+  def CopyToProto(self, proto):
+    """Copies this to a descriptor_pb2.MethodDescriptorProto.
+
+    Args:
+      proto (descriptor_pb2.MethodDescriptorProto): An empty descriptor proto.
+
+    Raises:
+      Error: If self couldn't be serialized, due to too few constructor
+        arguments.
+    """
+    if self.containing_service is not None:
+      from google.protobuf import descriptor_pb2
+      service_proto = descriptor_pb2.ServiceDescriptorProto()
+      self.containing_service.CopyToProto(service_proto)
+      proto.CopyFrom(service_proto.method[self.index])
+    else:
+      raise Error('Descriptor does not contain a service.')
+
+
+class FileDescriptor(DescriptorBase):
+  """Descriptor for a file. Mimics the descriptor_pb2.FileDescriptorProto.
+
+  Note that :attr:`enum_types_by_name`, :attr:`extensions_by_name`, and
+  :attr:`dependencies` fields are only set by the
+  :py:mod:`google.protobuf.message_factory` module, and not by the generated
+  proto code.
+
+  Attributes:
+    name (str): Name of file, relative to root of source tree.
+    package (str): Name of the package
+    edition (Edition): Enum value indicating edition of the file
+    serialized_pb (bytes): Byte string of serialized
+      :class:`descriptor_pb2.FileDescriptorProto`.
+    dependencies (list[FileDescriptor]): List of other :class:`FileDescriptor`
+      objects this :class:`FileDescriptor` depends on.
+    public_dependencies (list[FileDescriptor]): A subset of
+      :attr:`dependencies`, which were declared as "public".
+    message_types_by_name (dict(str, Descriptor)): Mapping from message names to
+      their :class:`Descriptor`.
+    enum_types_by_name (dict(str, EnumDescriptor)): Mapping from enum names to
+      their :class:`EnumDescriptor`.
+    extensions_by_name (dict(str, FieldDescriptor)): Mapping from extension
+      names declared at file scope to their :class:`FieldDescriptor`.
+    services_by_name (dict(str, ServiceDescriptor)): Mapping from services'
+      names to their :class:`ServiceDescriptor`.
+    pool (DescriptorPool): The pool this descriptor belongs to.  When not passed
+      to the constructor, the global default pool is used.
+  """
+
+  if _USE_C_DESCRIPTORS:
+    _C_DESCRIPTOR_CLASS = _message.FileDescriptor
+
+    def __new__(
+        cls,
+        name,
+        package,
+        options=None,
+        serialized_options=None,
+        serialized_pb=None,
+        dependencies=None,
+        public_dependencies=None,
+        syntax=None,
+        edition=None,
+        pool=None,
+        create_key=None,
+    ):
+      # FileDescriptor() is called from various places, not only from generated
+      # files, to register dynamic proto files and messages.
+      # pylint: disable=g-explicit-bool-comparison
+      if serialized_pb:
+        return _message.default_pool.AddSerializedFile(serialized_pb)
+      else:
+        return super(FileDescriptor, cls).__new__(cls)
+
+  def __init__(
+      self,
+      name,
+      package,
+      options=None,
+      serialized_options=None,
+      serialized_pb=None,
+      dependencies=None,
+      public_dependencies=None,
+      syntax=None,
+      edition=None,
+      pool=None,
+      create_key=None,
+  ):
+    """Constructor."""
+    if create_key is not _internal_create_key:
+      _Deprecated('FileDescriptor')
+
+    super(FileDescriptor, self).__init__(
+        self, options, serialized_options, 'FileOptions'
+    )
+
+    if edition and edition != 'EDITION_UNKNOWN':
+      self._edition = edition
+    elif syntax == 'proto3':
+      self._edition = 'EDITION_PROTO3'
+    else:
+      self._edition = 'EDITION_PROTO2'
+
+    if pool is None:
+      from google.protobuf import descriptor_pool
+      pool = descriptor_pool.Default()
+    self.pool = pool
+    self.message_types_by_name = {}
+    self.name = name
+    self.package = package
+    self.serialized_pb = serialized_pb
+
+    self.enum_types_by_name = {}
+    self.extensions_by_name = {}
+    self.services_by_name = {}
+    self.dependencies = (dependencies or [])
+    self.public_dependencies = (public_dependencies or [])
+
+  def CopyToProto(self, proto):
+    """Copies this to a descriptor_pb2.FileDescriptorProto.
+
+    Args:
+      proto: An empty descriptor_pb2.FileDescriptorProto.
+    """
+    proto.ParseFromString(self.serialized_pb)
+
+  @property
+  def _parent(self):
+    return None
+
+
+def _ParseOptions(message, string):
+  """Parses serialized options.
+
+  This helper function is used to parse serialized options in generated
+  proto2 files. It must not be used outside proto2.
+  """
+  message.ParseFromString(string)
+  return message
+
+
+def _ToCamelCase(name):
+  """Converts name to camel-case and returns it."""
+  capitalize_next = False
+  result = []
+
+  for c in name:
+    if c == '_':
+      if result:
+        capitalize_next = True
+    elif capitalize_next:
+      result.append(c.upper())
+      capitalize_next = False
+    else:
+      result += c
+
+  # Lower-case the first letter.
+  if result and result[0].isupper():
+    result[0] = result[0].lower()
+  return ''.join(result)
+
+
+def _OptionsOrNone(descriptor_proto):
+  """Returns the value of the field `options`, or None if it is not set."""
+  if descriptor_proto.HasField('options'):
+    return descriptor_proto.options
+  else:
+    return None
+
+
+def _ToJsonName(name):
+  """Converts name to Json name and returns it."""
+  capitalize_next = False
+  result = []
+
+  for c in name:
+    if c == '_':
+      capitalize_next = True
+    elif capitalize_next:
+      result.append(c.upper())
+      capitalize_next = False
+    else:
+      result += c
+
+  return ''.join(result)
+
+
+def MakeDescriptor(
+    desc_proto,
+    package='',
+    build_file_if_cpp=True,
+    syntax=None,
+    edition=None,
+    file_desc=None,
+):
+  """Make a protobuf Descriptor given a DescriptorProto protobuf.
+
+  Handles nested descriptors. Note that this is limited to the scope of defining
+  a message inside of another message. Composite fields can currently only be
+  resolved if the message is defined in the same scope as the field.
+
+  Args:
+    desc_proto: The descriptor_pb2.DescriptorProto protobuf message.
+    package: Optional package name for the new message Descriptor (string).
+    build_file_if_cpp: Update the C++ descriptor pool if api matches. Set to
+      False on recursion, so no duplicates are created.
+    syntax: The syntax/semantics that should be used.  Set to "proto3" to get
+      proto3 field presence semantics.
+    edition: The edition that should be used if syntax is "edition".
+    file_desc: A FileDescriptor to place this descriptor into.
+
+  Returns:
+    A Descriptor for protobuf messages.
+  """
+  # pylint: disable=g-import-not-at-top
+  from google.protobuf import descriptor_pb2
+
+  # Generate a random name for this proto file to prevent conflicts with any
+  # imported ones. We need to specify a file name so the descriptor pool
+  # accepts our FileDescriptorProto, but it is not important what that file
+  # name is actually set to.
+  proto_name = binascii.hexlify(os.urandom(16)).decode('ascii')
+
+  if package:
+    file_name = os.path.join(package.replace('.', '/'), proto_name + '.proto')
+  else:
+    file_name = proto_name + '.proto'
+
+  if api_implementation.Type() != 'python' and build_file_if_cpp:
+    # The C++ implementation requires all descriptors to be backed by the same
+    # definition in the C++ descriptor pool. To do this, we build a
+    # FileDescriptorProto with the same definition as this descriptor and build
+    # it into the pool.
+    file_descriptor_proto = descriptor_pb2.FileDescriptorProto()
+    file_descriptor_proto.message_type.add().MergeFrom(desc_proto)
+
+    if package:
+      file_descriptor_proto.package = package
+    file_descriptor_proto.name = file_name
+
+    _message.default_pool.Add(file_descriptor_proto)
+    result = _message.default_pool.FindFileByName(file_descriptor_proto.name)
+
+    if _USE_C_DESCRIPTORS:
+      return result.message_types_by_name[desc_proto.name]
+
+  if file_desc is None:
+    file_desc = FileDescriptor(
+        pool=None,
+        name=file_name,
+        package=package,
+        syntax=syntax,
+        edition=edition,
+        options=None,
+        serialized_pb='',
+        dependencies=[],
+        public_dependencies=[],
+        create_key=_internal_create_key,
+    )
+  full_message_name = [desc_proto.name]
+  if package: full_message_name.insert(0, package)
+
+  # Create Descriptors for enum types
+  enum_types = {}
+  for enum_proto in desc_proto.enum_type:
+    full_name = '.'.join(full_message_name + [enum_proto.name])
+    enum_desc = EnumDescriptor(
+        enum_proto.name,
+        full_name,
+        None,
+        [
+            EnumValueDescriptor(
+                enum_val.name,
+                ii,
+                enum_val.number,
+                create_key=_internal_create_key,
+            )
+            for ii, enum_val in enumerate(enum_proto.value)
+        ],
+        file=file_desc,
+        create_key=_internal_create_key,
+    )
+    enum_types[full_name] = enum_desc
+
+  # Create Descriptors for nested types
+  nested_types = {}
+  for nested_proto in desc_proto.nested_type:
+    full_name = '.'.join(full_message_name + [nested_proto.name])
+    # Nested types are just those defined inside of the message, not all types
+    # used by fields in the message, so no loops are possible here.
+    nested_desc = MakeDescriptor(
+        nested_proto,
+        package='.'.join(full_message_name),
+        build_file_if_cpp=False,
+        syntax=syntax,
+        edition=edition,
+        file_desc=file_desc,
+    )
+    nested_types[full_name] = nested_desc
+
+  fields = []
+  for field_proto in desc_proto.field:
+    full_name = '.'.join(full_message_name + [field_proto.name])
+    enum_desc = None
+    nested_desc = None
+    if field_proto.json_name:
+      json_name = field_proto.json_name
+    else:
+      json_name = None
+    if field_proto.HasField('type_name'):
+      type_name = field_proto.type_name
+      full_type_name = '.'.join(full_message_name +
+                                [type_name[type_name.rfind('.')+1:]])
+      if full_type_name in nested_types:
+        nested_desc = nested_types[full_type_name]
+      elif full_type_name in enum_types:
+        enum_desc = enum_types[full_type_name]
+      # Else type_name references a non-local type, which isn't implemented
+    field = FieldDescriptor(
+        field_proto.name,
+        full_name,
+        field_proto.number - 1,
+        field_proto.number,
+        field_proto.type,
+        FieldDescriptor.ProtoTypeToCppProtoType(field_proto.type),
+        field_proto.label,
+        None,
+        nested_desc,
+        enum_desc,
+        None,
+        False,
+        None,
+        options=_OptionsOrNone(field_proto),
+        has_default_value=False,
+        json_name=json_name,
+        file=file_desc,
+        create_key=_internal_create_key,
+    )
+    fields.append(field)
+
+  desc_name = '.'.join(full_message_name)
+  return Descriptor(
+      desc_proto.name,
+      desc_name,
+      None,
+      None,
+      fields,
+      list(nested_types.values()),
+      list(enum_types.values()),
+      [],
+      options=_OptionsOrNone(desc_proto),
+      file=file_desc,
+      create_key=_internal_create_key,
+  )

.venv/lib/python3.11/site-packages/google/protobuf/descriptor_database.py

@@ -0,0 +1,154 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+"""Provides a container for DescriptorProtos."""
+
+__author__ = 'matthewtoia@google.com (Matt Toia)'
+
+import warnings
+
+
+class Error(Exception):
+  pass
+
+
+class DescriptorDatabaseConflictingDefinitionError(Error):
+  """Raised when a proto is added with the same name & different descriptor."""
+
+
+class DescriptorDatabase(object):
+  """A container accepting FileDescriptorProtos and maps DescriptorProtos."""
+
+  def __init__(self):
+    self._file_desc_protos_by_file = {}
+    self._file_desc_protos_by_symbol = {}
+
+  def Add(self, file_desc_proto):
+    """Adds the FileDescriptorProto and its types to this database.
+
+    Args:
+      file_desc_proto: The FileDescriptorProto to add.
+    Raises:
+      DescriptorDatabaseConflictingDefinitionError: if an attempt is made to
+        add a proto with the same name but different definition than an
+        existing proto in the database.
+    """
+    proto_name = file_desc_proto.name
+    if proto_name not in self._file_desc_protos_by_file:
+      self._file_desc_protos_by_file[proto_name] = file_desc_proto
+    elif self._file_desc_protos_by_file[proto_name] != file_desc_proto:
+      raise DescriptorDatabaseConflictingDefinitionError(
+          '%s already added, but with different descriptor.' % proto_name)
+    else:
+      return
+
+    # Add all the top-level descriptors to the index.
+    package = file_desc_proto.package
+    for message in file_desc_proto.message_type:
+      for name in _ExtractSymbols(message, package):
+        self._AddSymbol(name, file_desc_proto)
+    for enum in file_desc_proto.enum_type:
+      self._AddSymbol(('.'.join((package, enum.name))), file_desc_proto)
+      for enum_value in enum.value:
+        self._file_desc_protos_by_symbol[
+            '.'.join((package, enum_value.name))] = file_desc_proto
+    for extension in file_desc_proto.extension:
+      self._AddSymbol(('.'.join((package, extension.name))), file_desc_proto)
+    for service in file_desc_proto.service:
+      self._AddSymbol(('.'.join((package, service.name))), file_desc_proto)
+
+  def FindFileByName(self, name):
+    """Finds the file descriptor proto by file name.
+
+    Typically the file name is a relative path ending to a .proto file. The
+    proto with the given name will have to have been added to this database
+    using the Add method or else an error will be raised.
+
+    Args:
+      name: The file name to find.
+
+    Returns:
+      The file descriptor proto matching the name.
+
+    Raises:
+      KeyError if no file by the given name was added.
+    """
+
+    return self._file_desc_protos_by_file[name]
+
+  def FindFileContainingSymbol(self, symbol):
+    """Finds the file descriptor proto containing the specified symbol.
+
+    The symbol should be a fully qualified name including the file descriptor's
+    package and any containing messages. Some examples:
+
+    'some.package.name.Message'
+    'some.package.name.Message.NestedEnum'
+    'some.package.name.Message.some_field'
+
+    The file descriptor proto containing the specified symbol must be added to
+    this database using the Add method or else an error will be raised.
+
+    Args:
+      symbol: The fully qualified symbol name.
+
+    Returns:
+      The file descriptor proto containing the symbol.
+
+    Raises:
+      KeyError if no file contains the specified symbol.
+    """
+    try:
+      return self._file_desc_protos_by_symbol[symbol]
+    except KeyError:
+      # Fields, enum values, and nested extensions are not in
+      # _file_desc_protos_by_symbol. Try to find the top level
+      # descriptor. Non-existent nested symbol under a valid top level
+      # descriptor can also be found. The behavior is the same with
+      # protobuf C++.
+      top_level, _, _ = symbol.rpartition('.')
+      try:
+        return self._file_desc_protos_by_symbol[top_level]
+      except KeyError:
+        # Raise the original symbol as a KeyError for better diagnostics.
+        raise KeyError(symbol)
+
+  def FindFileContainingExtension(self, extendee_name, extension_number):
+    # TODO: implement this API.
+    return None
+
+  def FindAllExtensionNumbers(self, extendee_name):
+    # TODO: implement this API.
+    return []
+
+  def _AddSymbol(self, name, file_desc_proto):
+    if name in self._file_desc_protos_by_symbol:
+      warn_msg = ('Conflict register for file "' + file_desc_proto.name +
+                  '": ' + name +
+                  ' is already defined in file "' +
+                  self._file_desc_protos_by_symbol[name].name + '"')
+      warnings.warn(warn_msg, RuntimeWarning)
+    self._file_desc_protos_by_symbol[name] = file_desc_proto
+
+
+def _ExtractSymbols(desc_proto, package):
+  """Pulls out all the symbols from a descriptor proto.
+
+  Args:
+    desc_proto: The proto to extract symbols from.
+    package: The package containing the descriptor type.
+
+  Yields:
+    The fully qualified name found in the descriptor.
+  """
+  message_name = package + '.' + desc_proto.name if package else desc_proto.name
+  yield message_name
+  for nested_type in desc_proto.nested_type:
+    for symbol in _ExtractSymbols(nested_type, message_name):
+      yield symbol
+  for enum_type in desc_proto.enum_type:
+    yield '.'.join((message_name, enum_type.name))

.venv/lib/python3.11/site-packages/google/protobuf/descriptor_pool.py

@@ -0,0 +1,1355 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+"""Provides DescriptorPool to use as a container for proto2 descriptors.
+
+The DescriptorPool is used in conjection with a DescriptorDatabase to maintain
+a collection of protocol buffer descriptors for use when dynamically creating
+message types at runtime.
+
+For most applications protocol buffers should be used via modules generated by
+the protocol buffer compiler tool. This should only be used when the type of
+protocol buffers used in an application or library cannot be predetermined.
+
+Below is a straightforward example on how to use this class::
+
+  pool = DescriptorPool()
+  file_descriptor_protos = [ ... ]
+  for file_descriptor_proto in file_descriptor_protos:
+    pool.Add(file_descriptor_proto)
+  my_message_descriptor = pool.FindMessageTypeByName('some.package.MessageType')
+
+The message descriptor can be used in conjunction with the message_factory
+module in order to create a protocol buffer class that can be encoded and
+decoded.
+
+If you want to get a Python class for the specified proto, use the
+helper functions inside google.protobuf.message_factory
+directly instead of this class.
+"""
+
+__author__ = 'matthewtoia@google.com (Matt Toia)'
+
+import collections
+import threading
+import warnings
+
+from google.protobuf import descriptor
+from google.protobuf import descriptor_database
+from google.protobuf import text_encoding
+from google.protobuf.internal import python_edition_defaults
+from google.protobuf.internal import python_message
+
+_USE_C_DESCRIPTORS = descriptor._USE_C_DESCRIPTORS  # pylint: disable=protected-access
+
+
+def _NormalizeFullyQualifiedName(name):
+  """Remove leading period from fully-qualified type name.
+
+  Due to b/13860351 in descriptor_database.py, types in the root namespace are
+  generated with a leading period. This function removes that prefix.
+
+  Args:
+    name (str): The fully-qualified symbol name.
+
+  Returns:
+    str: The normalized fully-qualified symbol name.
+  """
+  return name.lstrip('.')
+
+
+def _OptionsOrNone(descriptor_proto):
+  """Returns the value of the field `options`, or None if it is not set."""
+  if descriptor_proto.HasField('options'):
+    return descriptor_proto.options
+  else:
+    return None
+
+
+def _IsMessageSetExtension(field):
+  return (field.is_extension and
+          field.containing_type.has_options and
+          field.containing_type.GetOptions().message_set_wire_format and
+          field.type == descriptor.FieldDescriptor.TYPE_MESSAGE and
+          field.label == descriptor.FieldDescriptor.LABEL_OPTIONAL)
+
+_edition_defaults_lock = threading.Lock()
+
+
+class DescriptorPool(object):
+  """A collection of protobufs dynamically constructed by descriptor protos."""
+
+  if _USE_C_DESCRIPTORS:
+
+   def __new__(cls, descriptor_db=None):
+     # pylint: disable=protected-access
+     return descriptor._message.DescriptorPool(descriptor_db)
+
+  def __init__(
+      self, descriptor_db=None, use_deprecated_legacy_json_field_conflicts=False
+  ):
+    """Initializes a Pool of proto buffs.
+
+    The descriptor_db argument to the constructor is provided to allow
+    specialized file descriptor proto lookup code to be triggered on demand. An
+    example would be an implementation which will read and compile a file
+    specified in a call to FindFileByName() and not require the call to Add()
+    at all. Results from this database will be cached internally here as well.
+
+    Args:
+      descriptor_db: A secondary source of file descriptors.
+      use_deprecated_legacy_json_field_conflicts: Unused, for compatibility with
+        C++.
+    """
+
+    self._internal_db = descriptor_database.DescriptorDatabase()
+    self._descriptor_db = descriptor_db
+    self._descriptors = {}
+    self._enum_descriptors = {}
+    self._service_descriptors = {}
+    self._file_descriptors = {}
+    self._toplevel_extensions = {}
+    self._top_enum_values = {}
+    # We store extensions in two two-level mappings: The first key is the
+    # descriptor of the message being extended, the second key is the extension
+    # full name or its tag number.
+    self._extensions_by_name = collections.defaultdict(dict)
+    self._extensions_by_number = collections.defaultdict(dict)
+    self._serialized_edition_defaults = (
+        python_edition_defaults._PROTOBUF_INTERNAL_PYTHON_EDITION_DEFAULTS
+    )
+    self._edition_defaults = None
+    self._feature_cache = dict()
+
+  def _CheckConflictRegister(self, desc, desc_name, file_name):
+    """Check if the descriptor name conflicts with another of the same name.
+
+    Args:
+      desc: Descriptor of a message, enum, service, extension or enum value.
+      desc_name (str): the full name of desc.
+      file_name (str): The file name of descriptor.
+    """
+    for register, descriptor_type in [
+        (self._descriptors, descriptor.Descriptor),
+        (self._enum_descriptors, descriptor.EnumDescriptor),
+        (self._service_descriptors, descriptor.ServiceDescriptor),
+        (self._toplevel_extensions, descriptor.FieldDescriptor),
+        (self._top_enum_values, descriptor.EnumValueDescriptor)]:
+      if desc_name in register:
+        old_desc = register[desc_name]
+        if isinstance(old_desc, descriptor.EnumValueDescriptor):
+          old_file = old_desc.type.file.name
+        else:
+          old_file = old_desc.file.name
+
+        if not isinstance(desc, descriptor_type) or (
+            old_file != file_name):
+          error_msg = ('Conflict register for file "' + file_name +
+                       '": ' + desc_name +
+                       ' is already defined in file "' +
+                       old_file + '". Please fix the conflict by adding '
+                       'package name on the proto file, or use different '
+                       'name for the duplication.')
+          if isinstance(desc, descriptor.EnumValueDescriptor):
+            error_msg += ('\nNote: enum values appear as '
+                          'siblings of the enum type instead of '
+                          'children of it.')
+
+          raise TypeError(error_msg)
+
+        return
+
+  def Add(self, file_desc_proto):
+    """Adds the FileDescriptorProto and its types to this pool.
+
+    Args:
+      file_desc_proto (FileDescriptorProto): The file descriptor to add.
+    """
+
+    self._internal_db.Add(file_desc_proto)
+
+  def AddSerializedFile(self, serialized_file_desc_proto):
+    """Adds the FileDescriptorProto and its types to this pool.
+
+    Args:
+      serialized_file_desc_proto (bytes): A bytes string, serialization of the
+        :class:`FileDescriptorProto` to add.
+
+    Returns:
+      FileDescriptor: Descriptor for the added file.
+    """
+
+    # pylint: disable=g-import-not-at-top
+    from google.protobuf import descriptor_pb2
+    file_desc_proto = descriptor_pb2.FileDescriptorProto.FromString(
+        serialized_file_desc_proto)
+    file_desc = self._ConvertFileProtoToFileDescriptor(file_desc_proto)
+    file_desc.serialized_pb = serialized_file_desc_proto
+    return file_desc
+
+  # Never call this method. It is for internal usage only.
+  def _AddDescriptor(self, desc):
+    """Adds a Descriptor to the pool, non-recursively.
+
+    If the Descriptor contains nested messages or enums, the caller must
+    explicitly register them. This method also registers the FileDescriptor
+    associated with the message.
+
+    Args:
+      desc: A Descriptor.
+    """
+    if not isinstance(desc, descriptor.Descriptor):
+      raise TypeError('Expected instance of descriptor.Descriptor.')
+
+    self._CheckConflictRegister(desc, desc.full_name, desc.file.name)
+
+    self._descriptors[desc.full_name] = desc
+    self._AddFileDescriptor(desc.file)
+
+  # Never call this method. It is for internal usage only.
+  def _AddEnumDescriptor(self, enum_desc):
+    """Adds an EnumDescriptor to the pool.
+
+    This method also registers the FileDescriptor associated with the enum.
+
+    Args:
+      enum_desc: An EnumDescriptor.
+    """
+
+    if not isinstance(enum_desc, descriptor.EnumDescriptor):
+      raise TypeError('Expected instance of descriptor.EnumDescriptor.')
+
+    file_name = enum_desc.file.name
+    self._CheckConflictRegister(enum_desc, enum_desc.full_name, file_name)
+    self._enum_descriptors[enum_desc.full_name] = enum_desc
+
+    # Top enum values need to be indexed.
+    # Count the number of dots to see whether the enum is toplevel or nested
+    # in a message. We cannot use enum_desc.containing_type at this stage.
+    if enum_desc.file.package:
+      top_level = (enum_desc.full_name.count('.')
+                   - enum_desc.file.package.count('.') == 1)
+    else:
+      top_level = enum_desc.full_name.count('.') == 0
+    if top_level:
+      file_name = enum_desc.file.name
+      package = enum_desc.file.package
+      for enum_value in enum_desc.values:
+        full_name = _NormalizeFullyQualifiedName(
+            '.'.join((package, enum_value.name)))
+        self._CheckConflictRegister(enum_value, full_name, file_name)
+        self._top_enum_values[full_name] = enum_value
+    self._AddFileDescriptor(enum_desc.file)
+
+  # Never call this method. It is for internal usage only.
+  def _AddServiceDescriptor(self, service_desc):
+    """Adds a ServiceDescriptor to the pool.
+
+    Args:
+      service_desc: A ServiceDescriptor.
+    """
+
+    if not isinstance(service_desc, descriptor.ServiceDescriptor):
+      raise TypeError('Expected instance of descriptor.ServiceDescriptor.')
+
+    self._CheckConflictRegister(service_desc, service_desc.full_name,
+                                service_desc.file.name)
+    self._service_descriptors[service_desc.full_name] = service_desc
+
+  # Never call this method. It is for internal usage only.
+  def _AddExtensionDescriptor(self, extension):
+    """Adds a FieldDescriptor describing an extension to the pool.
+
+    Args:
+      extension: A FieldDescriptor.
+
+    Raises:
+      AssertionError: when another extension with the same number extends the
+        same message.
+      TypeError: when the specified extension is not a
+        descriptor.FieldDescriptor.
+    """
+    if not (isinstance(extension, descriptor.FieldDescriptor) and
+            extension.is_extension):
+      raise TypeError('Expected an extension descriptor.')
+
+    if extension.extension_scope is None:
+      self._CheckConflictRegister(
+          extension, extension.full_name, extension.file.name)
+      self._toplevel_extensions[extension.full_name] = extension
+
+    try:
+      existing_desc = self._extensions_by_number[
+          extension.containing_type][extension.number]
+    except KeyError:
+      pass
+    else:
+      if extension is not existing_desc:
+        raise AssertionError(
+            'Extensions "%s" and "%s" both try to extend message type "%s" '
+            'with field number %d.' %
+            (extension.full_name, existing_desc.full_name,
+             extension.containing_type.full_name, extension.number))
+
+    self._extensions_by_number[extension.containing_type][
+        extension.number] = extension
+    self._extensions_by_name[extension.containing_type][
+        extension.full_name] = extension
+
+    # Also register MessageSet extensions with the type name.
+    if _IsMessageSetExtension(extension):
+      self._extensions_by_name[extension.containing_type][
+          extension.message_type.full_name] = extension
+
+    if hasattr(extension.containing_type, '_concrete_class'):
+      python_message._AttachFieldHelpers(
+          extension.containing_type._concrete_class, extension)
+
+  # Never call this method. It is for internal usage only.
+  def _InternalAddFileDescriptor(self, file_desc):
+    """Adds a FileDescriptor to the pool, non-recursively.
+
+    If the FileDescriptor contains messages or enums, the caller must explicitly
+    register them.
+
+    Args:
+      file_desc: A FileDescriptor.
+    """
+
+    self._AddFileDescriptor(file_desc)
+
+  def _AddFileDescriptor(self, file_desc):
+    """Adds a FileDescriptor to the pool, non-recursively.
+
+    If the FileDescriptor contains messages or enums, the caller must explicitly
+    register them.
+
+    Args:
+      file_desc: A FileDescriptor.
+    """
+
+    if not isinstance(file_desc, descriptor.FileDescriptor):
+      raise TypeError('Expected instance of descriptor.FileDescriptor.')
+    self._file_descriptors[file_desc.name] = file_desc
+
+  def FindFileByName(self, file_name):
+    """Gets a FileDescriptor by file name.
+
+    Args:
+      file_name (str): The path to the file to get a descriptor for.
+
+    Returns:
+      FileDescriptor: The descriptor for the named file.
+
+    Raises:
+      KeyError: if the file cannot be found in the pool.
+    """
+
+    try:
+      return self._file_descriptors[file_name]
+    except KeyError:
+      pass
+
+    try:
+      file_proto = self._internal_db.FindFileByName(file_name)
+    except KeyError as error:
+      if self._descriptor_db:
+        file_proto = self._descriptor_db.FindFileByName(file_name)
+      else:
+        raise error
+    if not file_proto:
+      raise KeyError('Cannot find a file named %s' % file_name)
+    return self._ConvertFileProtoToFileDescriptor(file_proto)
+
+  def FindFileContainingSymbol(self, symbol):
+    """Gets the FileDescriptor for the file containing the specified symbol.
+
+    Args:
+      symbol (str): The name of the symbol to search for.
+
+    Returns:
+      FileDescriptor: Descriptor for the file that contains the specified
+      symbol.
+
+    Raises:
+      KeyError: if the file cannot be found in the pool.
+    """
+
+    symbol = _NormalizeFullyQualifiedName(symbol)
+    try:
+      return self._InternalFindFileContainingSymbol(symbol)
+    except KeyError:
+      pass
+
+    try:
+      # Try fallback database. Build and find again if possible.
+      self._FindFileContainingSymbolInDb(symbol)
+      return self._InternalFindFileContainingSymbol(symbol)
+    except KeyError:
+      raise KeyError('Cannot find a file containing %s' % symbol)
+
+  def _InternalFindFileContainingSymbol(self, symbol):
+    """Gets the already built FileDescriptor containing the specified symbol.
+
+    Args:
+      symbol (str): The name of the symbol to search for.
+
+    Returns:
+      FileDescriptor: Descriptor for the file that contains the specified
+      symbol.
+
+    Raises:
+      KeyError: if the file cannot be found in the pool.
+    """
+    try:
+      return self._descriptors[symbol].file
+    except KeyError:
+      pass
+
+    try:
+      return self._enum_descriptors[symbol].file
+    except KeyError:
+      pass
+
+    try:
+      return self._service_descriptors[symbol].file
+    except KeyError:
+      pass
+
+    try:
+      return self._top_enum_values[symbol].type.file
+    except KeyError:
+      pass
+
+    try:
+      return self._toplevel_extensions[symbol].file
+    except KeyError:
+      pass
+
+    # Try fields, enum values and nested extensions inside a message.
+    top_name, _, sub_name = symbol.rpartition('.')
+    try:
+      message = self.FindMessageTypeByName(top_name)
+      assert (sub_name in message.extensions_by_name or
+              sub_name in message.fields_by_name or
+              sub_name in message.enum_values_by_name)
+      return message.file
+    except (KeyError, AssertionError):
+      raise KeyError('Cannot find a file containing %s' % symbol)
+
+  def FindMessageTypeByName(self, full_name):
+    """Loads the named descriptor from the pool.
+
+    Args:
+      full_name (str): The full name of the descriptor to load.
+
+    Returns:
+      Descriptor: The descriptor for the named type.
+
+    Raises:
+      KeyError: if the message cannot be found in the pool.
+    """
+
+    full_name = _NormalizeFullyQualifiedName(full_name)
+    if full_name not in self._descriptors:
+      self._FindFileContainingSymbolInDb(full_name)
+    return self._descriptors[full_name]
+
+  def FindEnumTypeByName(self, full_name):
+    """Loads the named enum descriptor from the pool.
+
+    Args:
+      full_name (str): The full name of the enum descriptor to load.
+
+    Returns:
+      EnumDescriptor: The enum descriptor for the named type.
+
+    Raises:
+      KeyError: if the enum cannot be found in the pool.
+    """
+
+    full_name = _NormalizeFullyQualifiedName(full_name)
+    if full_name not in self._enum_descriptors:
+      self._FindFileContainingSymbolInDb(full_name)
+    return self._enum_descriptors[full_name]
+
+  def FindFieldByName(self, full_name):
+    """Loads the named field descriptor from the pool.
+
+    Args:
+      full_name (str): The full name of the field descriptor to load.
+
+    Returns:
+      FieldDescriptor: The field descriptor for the named field.
+
+    Raises:
+      KeyError: if the field cannot be found in the pool.
+    """
+    full_name = _NormalizeFullyQualifiedName(full_name)
+    message_name, _, field_name = full_name.rpartition('.')
+    message_descriptor = self.FindMessageTypeByName(message_name)
+    return message_descriptor.fields_by_name[field_name]
+
+  def FindOneofByName(self, full_name):
+    """Loads the named oneof descriptor from the pool.
+
+    Args:
+      full_name (str): The full name of the oneof descriptor to load.
+
+    Returns:
+      OneofDescriptor: The oneof descriptor for the named oneof.
+
+    Raises:
+      KeyError: if the oneof cannot be found in the pool.
+    """
+    full_name = _NormalizeFullyQualifiedName(full_name)
+    message_name, _, oneof_name = full_name.rpartition('.')
+    message_descriptor = self.FindMessageTypeByName(message_name)
+    return message_descriptor.oneofs_by_name[oneof_name]
+
+  def FindExtensionByName(self, full_name):
+    """Loads the named extension descriptor from the pool.
+
+    Args:
+      full_name (str): The full name of the extension descriptor to load.
+
+    Returns:
+      FieldDescriptor: The field descriptor for the named extension.
+
+    Raises:
+      KeyError: if the extension cannot be found in the pool.
+    """
+    full_name = _NormalizeFullyQualifiedName(full_name)
+    try:
+      # The proto compiler does not give any link between the FileDescriptor
+      # and top-level extensions unless the FileDescriptorProto is added to
+      # the DescriptorDatabase, but this can impact memory usage.
+      # So we registered these extensions by name explicitly.
+      return self._toplevel_extensions[full_name]
+    except KeyError:
+      pass
+    message_name, _, extension_name = full_name.rpartition('.')
+    try:
+      # Most extensions are nested inside a message.
+      scope = self.FindMessageTypeByName(message_name)
+    except KeyError:
+      # Some extensions are defined at file scope.
+      scope = self._FindFileContainingSymbolInDb(full_name)
+    return scope.extensions_by_name[extension_name]
+
+  def FindExtensionByNumber(self, message_descriptor, number):
+    """Gets the extension of the specified message with the specified number.
+
+    Extensions have to be registered to this pool by calling :func:`Add` or
+    :func:`AddExtensionDescriptor`.
+
+    Args:
+      message_descriptor (Descriptor): descriptor of the extended message.
+      number (int): Number of the extension field.
+
+    Returns:
+      FieldDescriptor: The descriptor for the extension.
+
+    Raises:
+      KeyError: when no extension with the given number is known for the
+        specified message.
+    """
+    try:
+      return self._extensions_by_number[message_descriptor][number]
+    except KeyError:
+      self._TryLoadExtensionFromDB(message_descriptor, number)
+      return self._extensions_by_number[message_descriptor][number]
+
+  def FindAllExtensions(self, message_descriptor):
+    """Gets all the known extensions of a given message.
+
+    Extensions have to be registered to this pool by build related
+    :func:`Add` or :func:`AddExtensionDescriptor`.
+
+    Args:
+      message_descriptor (Descriptor): Descriptor of the extended message.
+
+    Returns:
+      list[FieldDescriptor]: Field descriptors describing the extensions.
+    """
+    # Fallback to descriptor db if FindAllExtensionNumbers is provided.
+    if self._descriptor_db and hasattr(
+        self._descriptor_db, 'FindAllExtensionNumbers'):
+      full_name = message_descriptor.full_name
+      all_numbers = self._descriptor_db.FindAllExtensionNumbers(full_name)
+      for number in all_numbers:
+        if number in self._extensions_by_number[message_descriptor]:
+          continue
+        self._TryLoadExtensionFromDB(message_descriptor, number)
+
+    return list(self._extensions_by_number[message_descriptor].values())
+
+  def _TryLoadExtensionFromDB(self, message_descriptor, number):
+    """Try to Load extensions from descriptor db.
+
+    Args:
+      message_descriptor: descriptor of the extended message.
+      number: the extension number that needs to be loaded.
+    """
+    if not self._descriptor_db:
+      return
+    # Only supported when FindFileContainingExtension is provided.
+    if not hasattr(
+        self._descriptor_db, 'FindFileContainingExtension'):
+      return
+
+    full_name = message_descriptor.full_name
+    file_proto = self._descriptor_db.FindFileContainingExtension(
+        full_name, number)
+
+    if file_proto is None:
+      return
+
+    try:
+      self._ConvertFileProtoToFileDescriptor(file_proto)
+    except:
+      warn_msg = ('Unable to load proto file %s for extension number %d.' %
+                  (file_proto.name, number))
+      warnings.warn(warn_msg, RuntimeWarning)
+
+  def FindServiceByName(self, full_name):
+    """Loads the named service descriptor from the pool.
+
+    Args:
+      full_name (str): The full name of the service descriptor to load.
+
+    Returns:
+      ServiceDescriptor: The service descriptor for the named service.
+
+    Raises:
+      KeyError: if the service cannot be found in the pool.
+    """
+    full_name = _NormalizeFullyQualifiedName(full_name)
+    if full_name not in self._service_descriptors:
+      self._FindFileContainingSymbolInDb(full_name)
+    return self._service_descriptors[full_name]
+
+  def FindMethodByName(self, full_name):
+    """Loads the named service method descriptor from the pool.
+
+    Args:
+      full_name (str): The full name of the method descriptor to load.
+
+    Returns:
+      MethodDescriptor: The method descriptor for the service method.
+
+    Raises:
+      KeyError: if the method cannot be found in the pool.
+    """
+    full_name = _NormalizeFullyQualifiedName(full_name)
+    service_name, _, method_name = full_name.rpartition('.')
+    service_descriptor = self.FindServiceByName(service_name)
+    return service_descriptor.methods_by_name[method_name]
+
+  def SetFeatureSetDefaults(self, defaults):
+    """Sets the default feature mappings used during the build.
+
+    Args:
+      defaults: a FeatureSetDefaults message containing the new mappings.
+    """
+    if self._edition_defaults is not None:
+      raise ValueError(
+          "Feature set defaults can't be changed once the pool has started"
+          ' building!'
+      )
+
+    # pylint: disable=g-import-not-at-top
+    from google.protobuf import descriptor_pb2
+
+    if not isinstance(defaults, descriptor_pb2.FeatureSetDefaults):
+      raise TypeError('SetFeatureSetDefaults called with invalid type')
+
+
+    if defaults.minimum_edition > defaults.maximum_edition:
+      raise ValueError(
+          'Invalid edition range %s to %s'
+          % (
+              descriptor_pb2.Edition.Name(defaults.minimum_edition),
+              descriptor_pb2.Edition.Name(defaults.maximum_edition),
+          )
+      )
+
+    prev_edition = descriptor_pb2.Edition.EDITION_UNKNOWN
+    for d in defaults.defaults:
+      if d.edition == descriptor_pb2.Edition.EDITION_UNKNOWN:
+        raise ValueError('Invalid edition EDITION_UNKNOWN specified')
+      if prev_edition >= d.edition:
+        raise ValueError(
+            'Feature set defaults are not strictly increasing.  %s is greater'
+            ' than or equal to %s'
+            % (
+                descriptor_pb2.Edition.Name(prev_edition),
+                descriptor_pb2.Edition.Name(d.edition),
+            )
+        )
+      prev_edition = d.edition
+    self._edition_defaults = defaults
+
+  def _CreateDefaultFeatures(self, edition):
+    """Creates a FeatureSet message with defaults for a specific edition.
+
+    Args:
+      edition: the edition to generate defaults for.
+
+    Returns:
+      A FeatureSet message with defaults for a specific edition.
+    """
+    # pylint: disable=g-import-not-at-top
+    from google.protobuf import descriptor_pb2
+
+    with _edition_defaults_lock:
+      if not self._edition_defaults:
+        self._edition_defaults = descriptor_pb2.FeatureSetDefaults()
+        self._edition_defaults.ParseFromString(
+            self._serialized_edition_defaults
+        )
+
+    if edition < self._edition_defaults.minimum_edition:
+      raise TypeError(
+          'Edition %s is earlier than the minimum supported edition %s!'
+          % (
+              descriptor_pb2.Edition.Name(edition),
+              descriptor_pb2.Edition.Name(
+                  self._edition_defaults.minimum_edition
+              ),
+          )
+      )
+    if edition > self._edition_defaults.maximum_edition:
+      raise TypeError(
+          'Edition %s is later than the maximum supported edition %s!'
+          % (
+              descriptor_pb2.Edition.Name(edition),
+              descriptor_pb2.Edition.Name(
+                  self._edition_defaults.maximum_edition
+              ),
+          )
+      )
+    found = None
+    for d in self._edition_defaults.defaults:
+      if d.edition > edition:
+        break
+      found = d
+    if found is None:
+      raise TypeError(
+          'No valid default found for edition %s!'
+          % descriptor_pb2.Edition.Name(edition)
+      )
+
+    defaults = descriptor_pb2.FeatureSet()
+    defaults.CopyFrom(found.fixed_features)
+    defaults.MergeFrom(found.overridable_features)
+    return defaults
+
+  def _InternFeatures(self, features):
+    serialized = features.SerializeToString()
+    with _edition_defaults_lock:
+      cached = self._feature_cache.get(serialized)
+      if cached is None:
+        self._feature_cache[serialized] = features
+        cached = features
+    return cached
+
+  def _FindFileContainingSymbolInDb(self, symbol):
+    """Finds the file in descriptor DB containing the specified symbol.
+
+    Args:
+      symbol (str): The name of the symbol to search for.
+
+    Returns:
+      FileDescriptor: The file that contains the specified symbol.
+
+    Raises:
+      KeyError: if the file cannot be found in the descriptor database.
+    """
+    try:
+      file_proto = self._internal_db.FindFileContainingSymbol(symbol)
+    except KeyError as error:
+      if self._descriptor_db:
+        file_proto = self._descriptor_db.FindFileContainingSymbol(symbol)
+      else:
+        raise error
+    if not file_proto:
+      raise KeyError('Cannot find a file containing %s' % symbol)
+    return self._ConvertFileProtoToFileDescriptor(file_proto)
+
+  def _ConvertFileProtoToFileDescriptor(self, file_proto):
+    """Creates a FileDescriptor from a proto or returns a cached copy.
+
+    This method also has the side effect of loading all the symbols found in
+    the file into the appropriate dictionaries in the pool.
+
+    Args:
+      file_proto: The proto to convert.
+
+    Returns:
+      A FileDescriptor matching the passed in proto.
+    """
+    if file_proto.name not in self._file_descriptors:
+      built_deps = list(self._GetDeps(file_proto.dependency))
+      direct_deps = [self.FindFileByName(n) for n in file_proto.dependency]
+      public_deps = [direct_deps[i] for i in file_proto.public_dependency]
+
+      # pylint: disable=g-import-not-at-top
+      from google.protobuf import descriptor_pb2
+
+      file_descriptor = descriptor.FileDescriptor(
+          pool=self,
+          name=file_proto.name,
+          package=file_proto.package,
+          syntax=file_proto.syntax,
+          edition=descriptor_pb2.Edition.Name(file_proto.edition),
+          options=_OptionsOrNone(file_proto),
+          serialized_pb=file_proto.SerializeToString(),
+          dependencies=direct_deps,
+          public_dependencies=public_deps,
+          # pylint: disable=protected-access
+          create_key=descriptor._internal_create_key,
+      )
+      scope = {}
+
+      # This loop extracts all the message and enum types from all the
+      # dependencies of the file_proto. This is necessary to create the
+      # scope of available message types when defining the passed in
+      # file proto.
+      for dependency in built_deps:
+        scope.update(self._ExtractSymbols(
+            dependency.message_types_by_name.values()))
+        scope.update((_PrefixWithDot(enum.full_name), enum)
+                     for enum in dependency.enum_types_by_name.values())
+
+      for message_type in file_proto.message_type:
+        message_desc = self._ConvertMessageDescriptor(
+            message_type, file_proto.package, file_descriptor, scope,
+            file_proto.syntax)
+        file_descriptor.message_types_by_name[message_desc.name] = (
+            message_desc)
+
+      for enum_type in file_proto.enum_type:
+        file_descriptor.enum_types_by_name[enum_type.name] = (
+            self._ConvertEnumDescriptor(enum_type, file_proto.package,
+                                        file_descriptor, None, scope, True))
+
+      for index, extension_proto in enumerate(file_proto.extension):
+        extension_desc = self._MakeFieldDescriptor(
+            extension_proto, file_proto.package, index, file_descriptor,
+            is_extension=True)
+        extension_desc.containing_type = self._GetTypeFromScope(
+            file_descriptor.package, extension_proto.extendee, scope)
+        self._SetFieldType(extension_proto, extension_desc,
+                           file_descriptor.package, scope)
+        file_descriptor.extensions_by_name[extension_desc.name] = (
+            extension_desc)
+
+      for desc_proto in file_proto.message_type:
+        self._SetAllFieldTypes(file_proto.package, desc_proto, scope)
+
+      if file_proto.package:
+        desc_proto_prefix = _PrefixWithDot(file_proto.package)
+      else:
+        desc_proto_prefix = ''
+
+      for desc_proto in file_proto.message_type:
+        desc = self._GetTypeFromScope(
+            desc_proto_prefix, desc_proto.name, scope)
+        file_descriptor.message_types_by_name[desc_proto.name] = desc
+
+      for index, service_proto in enumerate(file_proto.service):
+        file_descriptor.services_by_name[service_proto.name] = (
+            self._MakeServiceDescriptor(service_proto, index, scope,
+                                        file_proto.package, file_descriptor))
+
+      self._file_descriptors[file_proto.name] = file_descriptor
+
+    # Add extensions to the pool
+    def AddExtensionForNested(message_type):
+      for nested in message_type.nested_types:
+        AddExtensionForNested(nested)
+      for extension in message_type.extensions:
+        self._AddExtensionDescriptor(extension)
+
+    file_desc = self._file_descriptors[file_proto.name]
+    for extension in file_desc.extensions_by_name.values():
+      self._AddExtensionDescriptor(extension)
+    for message_type in file_desc.message_types_by_name.values():
+      AddExtensionForNested(message_type)
+
+    return file_desc
+
+  def _ConvertMessageDescriptor(self, desc_proto, package=None, file_desc=None,
+                                scope=None, syntax=None):
+    """Adds the proto to the pool in the specified package.
+
+    Args:
+      desc_proto: The descriptor_pb2.DescriptorProto protobuf message.
+      package: The package the proto should be located in.
+      file_desc: The file containing this message.
+      scope: Dict mapping short and full symbols to message and enum types.
+      syntax: string indicating syntax of the file ("proto2" or "proto3")
+
+    Returns:
+      The added descriptor.
+    """
+
+    if package:
+      desc_name = '.'.join((package, desc_proto.name))
+    else:
+      desc_name = desc_proto.name
+
+    if file_desc is None:
+      file_name = None
+    else:
+      file_name = file_desc.name
+
+    if scope is None:
+      scope = {}
+
+    nested = [
+        self._ConvertMessageDescriptor(
+            nested, desc_name, file_desc, scope, syntax)
+        for nested in desc_proto.nested_type]
+    enums = [
+        self._ConvertEnumDescriptor(enum, desc_name, file_desc, None,
+                                    scope, False)
+        for enum in desc_proto.enum_type]
+    fields = [self._MakeFieldDescriptor(field, desc_name, index, file_desc)
+              for index, field in enumerate(desc_proto.field)]
+    extensions = [
+        self._MakeFieldDescriptor(extension, desc_name, index, file_desc,
+                                  is_extension=True)
+        for index, extension in enumerate(desc_proto.extension)]
+    oneofs = [
+        # pylint: disable=g-complex-comprehension
+        descriptor.OneofDescriptor(
+            desc.name,
+            '.'.join((desc_name, desc.name)),
+            index,
+            None,
+            [],
+            _OptionsOrNone(desc),
+            # pylint: disable=protected-access
+            create_key=descriptor._internal_create_key)
+        for index, desc in enumerate(desc_proto.oneof_decl)
+    ]
+    extension_ranges = [(r.start, r.end) for r in desc_proto.extension_range]
+    if extension_ranges:
+      is_extendable = True
+    else:
+      is_extendable = False
+    desc = descriptor.Descriptor(
+        name=desc_proto.name,
+        full_name=desc_name,
+        filename=file_name,
+        containing_type=None,
+        fields=fields,
+        oneofs=oneofs,
+        nested_types=nested,
+        enum_types=enums,
+        extensions=extensions,
+        options=_OptionsOrNone(desc_proto),
+        is_extendable=is_extendable,
+        extension_ranges=extension_ranges,
+        file=file_desc,
+        serialized_start=None,
+        serialized_end=None,
+        is_map_entry=desc_proto.options.map_entry,
+        # pylint: disable=protected-access
+        create_key=descriptor._internal_create_key,
+    )
+    for nested in desc.nested_types:
+      nested.containing_type = desc
+    for enum in desc.enum_types:
+      enum.containing_type = desc
+    for field_index, field_desc in enumerate(desc_proto.field):
+      if field_desc.HasField('oneof_index'):
+        oneof_index = field_desc.oneof_index
+        oneofs[oneof_index].fields.append(fields[field_index])
+        fields[field_index].containing_oneof = oneofs[oneof_index]
+
+    scope[_PrefixWithDot(desc_name)] = desc
+    self._CheckConflictRegister(desc, desc.full_name, desc.file.name)
+    self._descriptors[desc_name] = desc
+    return desc
+
+  def _ConvertEnumDescriptor(self, enum_proto, package=None, file_desc=None,
+                             containing_type=None, scope=None, top_level=False):
+    """Make a protobuf EnumDescriptor given an EnumDescriptorProto protobuf.
+
+    Args:
+      enum_proto: The descriptor_pb2.EnumDescriptorProto protobuf message.
+      package: Optional package name for the new message EnumDescriptor.
+      file_desc: The file containing the enum descriptor.
+      containing_type: The type containing this enum.
+      scope: Scope containing available types.
+      top_level: If True, the enum is a top level symbol. If False, the enum
+          is defined inside a message.
+
+    Returns:
+      The added descriptor
+    """
+
+    if package:
+      enum_name = '.'.join((package, enum_proto.name))
+    else:
+      enum_name = enum_proto.name
+
+    if file_desc is None:
+      file_name = None
+    else:
+      file_name = file_desc.name
+
+    values = [self._MakeEnumValueDescriptor(value, index)
+              for index, value in enumerate(enum_proto.value)]
+    desc = descriptor.EnumDescriptor(name=enum_proto.name,
+                                     full_name=enum_name,
+                                     filename=file_name,
+                                     file=file_desc,
+                                     values=values,
+                                     containing_type=containing_type,
+                                     options=_OptionsOrNone(enum_proto),
+                                     # pylint: disable=protected-access
+                                     create_key=descriptor._internal_create_key)
+    scope['.%s' % enum_name] = desc
+    self._CheckConflictRegister(desc, desc.full_name, desc.file.name)
+    self._enum_descriptors[enum_name] = desc
+
+    # Add top level enum values.
+    if top_level:
+      for value in values:
+        full_name = _NormalizeFullyQualifiedName(
+            '.'.join((package, value.name)))
+        self._CheckConflictRegister(value, full_name, file_name)
+        self._top_enum_values[full_name] = value
+
+    return desc
+
+  def _MakeFieldDescriptor(self, field_proto, message_name, index,
+                           file_desc, is_extension=False):
+    """Creates a field descriptor from a FieldDescriptorProto.
+
+    For message and enum type fields, this method will do a look up
+    in the pool for the appropriate descriptor for that type. If it
+    is unavailable, it will fall back to the _source function to
+    create it. If this type is still unavailable, construction will
+    fail.
+
+    Args:
+      field_proto: The proto describing the field.
+      message_name: The name of the containing message.
+      index: Index of the field
+      file_desc: The file containing the field descriptor.
+      is_extension: Indication that this field is for an extension.
+
+    Returns:
+      An initialized FieldDescriptor object
+    """
+
+    if message_name:
+      full_name = '.'.join((message_name, field_proto.name))
+    else:
+      full_name = field_proto.name
+
+    if field_proto.json_name:
+      json_name = field_proto.json_name
+    else:
+      json_name = None
+
+    return descriptor.FieldDescriptor(
+        name=field_proto.name,
+        full_name=full_name,
+        index=index,
+        number=field_proto.number,
+        type=field_proto.type,
+        cpp_type=None,
+        message_type=None,
+        enum_type=None,
+        containing_type=None,
+        label=field_proto.label,
+        has_default_value=False,
+        default_value=None,
+        is_extension=is_extension,
+        extension_scope=None,
+        options=_OptionsOrNone(field_proto),
+        json_name=json_name,
+        file=file_desc,
+        # pylint: disable=protected-access
+        create_key=descriptor._internal_create_key)
+
+  def _SetAllFieldTypes(self, package, desc_proto, scope):
+    """Sets all the descriptor's fields's types.
+
+    This method also sets the containing types on any extensions.
+
+    Args:
+      package: The current package of desc_proto.
+      desc_proto: The message descriptor to update.
+      scope: Enclosing scope of available types.
+    """
+
+    package = _PrefixWithDot(package)
+
+    main_desc = self._GetTypeFromScope(package, desc_proto.name, scope)
+
+    if package == '.':
+      nested_package = _PrefixWithDot(desc_proto.name)
+    else:
+      nested_package = '.'.join([package, desc_proto.name])
+
+    for field_proto, field_desc in zip(desc_proto.field, main_desc.fields):
+      self._SetFieldType(field_proto, field_desc, nested_package, scope)
+
+    for extension_proto, extension_desc in (
+        zip(desc_proto.extension, main_desc.extensions)):
+      extension_desc.containing_type = self._GetTypeFromScope(
+          nested_package, extension_proto.extendee, scope)
+      self._SetFieldType(extension_proto, extension_desc, nested_package, scope)
+
+    for nested_type in desc_proto.nested_type:
+      self._SetAllFieldTypes(nested_package, nested_type, scope)
+
+  def _SetFieldType(self, field_proto, field_desc, package, scope):
+    """Sets the field's type, cpp_type, message_type and enum_type.
+
+    Args:
+      field_proto: Data about the field in proto format.
+      field_desc: The descriptor to modify.
+      package: The package the field's container is in.
+      scope: Enclosing scope of available types.
+    """
+    if field_proto.type_name:
+      desc = self._GetTypeFromScope(package, field_proto.type_name, scope)
+    else:
+      desc = None
+
+    if not field_proto.HasField('type'):
+      if isinstance(desc, descriptor.Descriptor):
+        field_proto.type = descriptor.FieldDescriptor.TYPE_MESSAGE
+      else:
+        field_proto.type = descriptor.FieldDescriptor.TYPE_ENUM
+
+    field_desc.cpp_type = descriptor.FieldDescriptor.ProtoTypeToCppProtoType(
+        field_proto.type)
+
+    if (field_proto.type == descriptor.FieldDescriptor.TYPE_MESSAGE
+        or field_proto.type == descriptor.FieldDescriptor.TYPE_GROUP):
+      field_desc.message_type = desc
+
+    if field_proto.type == descriptor.FieldDescriptor.TYPE_ENUM:
+      field_desc.enum_type = desc
+
+    if field_proto.label == descriptor.FieldDescriptor.LABEL_REPEATED:
+      field_desc.has_default_value = False
+      field_desc.default_value = []
+    elif field_proto.HasField('default_value'):
+      field_desc.has_default_value = True
+      if (field_proto.type == descriptor.FieldDescriptor.TYPE_DOUBLE or
+          field_proto.type == descriptor.FieldDescriptor.TYPE_FLOAT):
+        field_desc.default_value = float(field_proto.default_value)
+      elif field_proto.type == descriptor.FieldDescriptor.TYPE_STRING:
+        field_desc.default_value = field_proto.default_value
+      elif field_proto.type == descriptor.FieldDescriptor.TYPE_BOOL:
+        field_desc.default_value = field_proto.default_value.lower() == 'true'
+      elif field_proto.type == descriptor.FieldDescriptor.TYPE_ENUM:
+        field_desc.default_value = field_desc.enum_type.values_by_name[
+            field_proto.default_value].number
+      elif field_proto.type == descriptor.FieldDescriptor.TYPE_BYTES:
+        field_desc.default_value = text_encoding.CUnescape(
+            field_proto.default_value)
+      elif field_proto.type == descriptor.FieldDescriptor.TYPE_MESSAGE:
+        field_desc.default_value = None
+      else:
+        # All other types are of the "int" type.
+        field_desc.default_value = int(field_proto.default_value)
+    else:
+      field_desc.has_default_value = False
+      if (field_proto.type == descriptor.FieldDescriptor.TYPE_DOUBLE or
+          field_proto.type == descriptor.FieldDescriptor.TYPE_FLOAT):
+        field_desc.default_value = 0.0
+      elif field_proto.type == descriptor.FieldDescriptor.TYPE_STRING:
+        field_desc.default_value = u''
+      elif field_proto.type == descriptor.FieldDescriptor.TYPE_BOOL:
+        field_desc.default_value = False
+      elif field_proto.type == descriptor.FieldDescriptor.TYPE_ENUM:
+        field_desc.default_value = field_desc.enum_type.values[0].number
+      elif field_proto.type == descriptor.FieldDescriptor.TYPE_BYTES:
+        field_desc.default_value = b''
+      elif field_proto.type == descriptor.FieldDescriptor.TYPE_MESSAGE:
+        field_desc.default_value = None
+      elif field_proto.type == descriptor.FieldDescriptor.TYPE_GROUP:
+        field_desc.default_value = None
+      else:
+        # All other types are of the "int" type.
+        field_desc.default_value = 0
+
+    field_desc.type = field_proto.type
+
+  def _MakeEnumValueDescriptor(self, value_proto, index):
+    """Creates a enum value descriptor object from a enum value proto.
+
+    Args:
+      value_proto: The proto describing the enum value.
+      index: The index of the enum value.
+
+    Returns:
+      An initialized EnumValueDescriptor object.
+    """
+
+    return descriptor.EnumValueDescriptor(
+        name=value_proto.name,
+        index=index,
+        number=value_proto.number,
+        options=_OptionsOrNone(value_proto),
+        type=None,
+        # pylint: disable=protected-access
+        create_key=descriptor._internal_create_key)
+
+  def _MakeServiceDescriptor(self, service_proto, service_index, scope,
+                             package, file_desc):
+    """Make a protobuf ServiceDescriptor given a ServiceDescriptorProto.
+
+    Args:
+      service_proto: The descriptor_pb2.ServiceDescriptorProto protobuf message.
+      service_index: The index of the service in the File.
+      scope: Dict mapping short and full symbols to message and enum types.
+      package: Optional package name for the new message EnumDescriptor.
+      file_desc: The file containing the service descriptor.
+
+    Returns:
+      The added descriptor.
+    """
+
+    if package:
+      service_name = '.'.join((package, service_proto.name))
+    else:
+      service_name = service_proto.name
+
+    methods = [self._MakeMethodDescriptor(method_proto, service_name, package,
+                                          scope, index)
+               for index, method_proto in enumerate(service_proto.method)]
+    desc = descriptor.ServiceDescriptor(
+        name=service_proto.name,
+        full_name=service_name,
+        index=service_index,
+        methods=methods,
+        options=_OptionsOrNone(service_proto),
+        file=file_desc,
+        # pylint: disable=protected-access
+        create_key=descriptor._internal_create_key)
+    self._CheckConflictRegister(desc, desc.full_name, desc.file.name)
+    self._service_descriptors[service_name] = desc
+    return desc
+
+  def _MakeMethodDescriptor(self, method_proto, service_name, package, scope,
+                            index):
+    """Creates a method descriptor from a MethodDescriptorProto.
+
+    Args:
+      method_proto: The proto describing the method.
+      service_name: The name of the containing service.
+      package: Optional package name to look up for types.
+      scope: Scope containing available types.
+      index: Index of the method in the service.
+
+    Returns:
+      An initialized MethodDescriptor object.
+    """
+    full_name = '.'.join((service_name, method_proto.name))
+    input_type = self._GetTypeFromScope(
+        package, method_proto.input_type, scope)
+    output_type = self._GetTypeFromScope(
+        package, method_proto.output_type, scope)
+    return descriptor.MethodDescriptor(
+        name=method_proto.name,
+        full_name=full_name,
+        index=index,
+        containing_service=None,
+        input_type=input_type,
+        output_type=output_type,
+        client_streaming=method_proto.client_streaming,
+        server_streaming=method_proto.server_streaming,
+        options=_OptionsOrNone(method_proto),
+        # pylint: disable=protected-access
+        create_key=descriptor._internal_create_key)
+
+  def _ExtractSymbols(self, descriptors):
+    """Pulls out all the symbols from descriptor protos.
+
+    Args:
+      descriptors: The messages to extract descriptors from.
+    Yields:
+      A two element tuple of the type name and descriptor object.
+    """
+
+    for desc in descriptors:
+      yield (_PrefixWithDot(desc.full_name), desc)
+      for symbol in self._ExtractSymbols(desc.nested_types):
+        yield symbol
+      for enum in desc.enum_types:
+        yield (_PrefixWithDot(enum.full_name), enum)
+
+  def _GetDeps(self, dependencies, visited=None):
+    """Recursively finds dependencies for file protos.
+
+    Args:
+      dependencies: The names of the files being depended on.
+      visited: The names of files already found.
+
+    Yields:
+      Each direct and indirect dependency.
+    """
+
+    visited = visited or set()
+    for dependency in dependencies:
+      if dependency not in visited:
+        visited.add(dependency)
+        dep_desc = self.FindFileByName(dependency)
+        yield dep_desc
+        public_files = [d.name for d in dep_desc.public_dependencies]
+        yield from self._GetDeps(public_files, visited)
+
+  def _GetTypeFromScope(self, package, type_name, scope):
+    """Finds a given type name in the current scope.
+
+    Args:
+      package: The package the proto should be located in.
+      type_name: The name of the type to be found in the scope.
+      scope: Dict mapping short and full symbols to message and enum types.
+
+    Returns:
+      The descriptor for the requested type.
+    """
+    if type_name not in scope:
+      components = _PrefixWithDot(package).split('.')
+      while components:
+        possible_match = '.'.join(components + [type_name])
+        if possible_match in scope:
+          type_name = possible_match
+          break
+        else:
+          components.pop(-1)
+    return scope[type_name]
+
+
+def _PrefixWithDot(name):
+  return name if name.startswith('.') else '.%s' % name
+
+
+if _USE_C_DESCRIPTORS:
+  # TODO: This pool could be constructed from Python code, when we
+  # support a flag like 'use_cpp_generated_pool=True'.
+  # pylint: disable=protected-access
+  _DEFAULT = descriptor._message.default_pool
+else:
+  _DEFAULT = DescriptorPool()
+
+
+def Default():
+  return _DEFAULT

.venv/lib/python3.11/site-packages/google/protobuf/duration.py

@@ -0,0 +1,100 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+"""Contains the Duration helper APIs."""
+
+import datetime
+
+from google.protobuf.duration_pb2 import Duration
+
+
+def from_json_string(value: str) -> Duration:
+  """Converts a string to Duration.
+
+  Args:
+    value: A string to be converted. The string must end with 's'. Any
+      fractional digits (or none) are accepted as long as they fit into
+      precision. For example: "1s", "1.01s", "1.0000001s", "-3.100s"
+
+  Raises:
+    ValueError: On parsing problems.
+  """
+  duration = Duration()
+  duration.FromJsonString(value)
+  return duration
+
+
+def from_microseconds(micros: float) -> Duration:
+  """Converts microseconds to Duration."""
+  duration = Duration()
+  duration.FromMicroseconds(micros)
+  return duration
+
+
+def from_milliseconds(millis: float) -> Duration:
+  """Converts milliseconds to Duration."""
+  duration = Duration()
+  duration.FromMilliseconds(millis)
+  return duration
+
+
+def from_nanoseconds(nanos: float) -> Duration:
+  """Converts nanoseconds to Duration."""
+  duration = Duration()
+  duration.FromNanoseconds(nanos)
+  return duration
+
+
+def from_seconds(seconds: float) -> Duration:
+  """Converts seconds to Duration."""
+  duration = Duration()
+  duration.FromSeconds(seconds)
+  return duration
+
+
+def from_timedelta(td: datetime.timedelta) -> Duration:
+  """Converts timedelta to Duration."""
+  duration = Duration()
+  duration.FromTimedelta(td)
+  return duration
+
+
+def to_json_string(duration: Duration) -> str:
+  """Converts Duration to string format.
+
+  Returns:
+    A string converted from self. The string format will contains
+    3, 6, or 9 fractional digits depending on the precision required to
+    represent the exact Duration value. For example: "1s", "1.010s",
+    "1.000000100s", "-3.100s"
+  """
+  return duration.ToJsonString()
+
+
+def to_microseconds(duration: Duration) -> int:
+  """Converts a Duration to microseconds."""
+  return duration.ToMicroseconds()
+
+
+def to_milliseconds(duration: Duration) -> int:
+  """Converts a Duration to milliseconds."""
+  return duration.ToMilliseconds()
+
+
+def to_nanoseconds(duration: Duration) -> int:
+  """Converts a Duration to nanoseconds."""
+  return duration.ToNanoseconds()
+
+
+def to_seconds(duration: Duration) -> int:
+  """Converts a Duration to seconds."""
+  return duration.ToSeconds()
+
+
+def to_timedelta(duration: Duration) -> datetime.timedelta:
+  """Converts Duration to timedelta."""
+  return duration.ToTimedelta()

.venv/lib/python3.11/site-packages/google/protobuf/duration_pb2.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: google/protobuf/duration.proto
+# Protobuf Python Version: 5.29.3
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    5,
+    29,
+    3,
+    '',
+    'google/protobuf/duration.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1egoogle/protobuf/duration.proto\x12\x0fgoogle.protobuf\":\n\x08\x44uration\x12\x18\n\x07seconds\x18\x01 \x01(\x03R\x07seconds\x12\x14\n\x05nanos\x18\x02 \x01(\x05R\x05nanosB\x83\x01\n\x13\x63om.google.protobufB\rDurationProtoP\x01Z1google.golang.org/protobuf/types/known/durationpb\xf8\x01\x01\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.duration_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  _globals['DESCRIPTOR']._loaded_options = None
+  _globals['DESCRIPTOR']._serialized_options = b'\n\023com.google.protobufB\rDurationProtoP\001Z1google.golang.org/protobuf/types/known/durationpb\370\001\001\242\002\003GPB\252\002\036Google.Protobuf.WellKnownTypes'
+  _globals['_DURATION']._serialized_start=51
+  _globals['_DURATION']._serialized_end=109
+# @@protoc_insertion_point(module_scope)

.venv/lib/python3.11/site-packages/google/protobuf/empty_pb2.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: google/protobuf/empty.proto
+# Protobuf Python Version: 5.29.3
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    5,
+    29,
+    3,
+    '',
+    'google/protobuf/empty.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1bgoogle/protobuf/empty.proto\x12\x0fgoogle.protobuf\"\x07\n\x05\x45mptyB}\n\x13\x63om.google.protobufB\nEmptyProtoP\x01Z.google.golang.org/protobuf/types/known/emptypb\xf8\x01\x01\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.empty_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  _globals['DESCRIPTOR']._loaded_options = None
+  _globals['DESCRIPTOR']._serialized_options = b'\n\023com.google.protobufB\nEmptyProtoP\001Z.google.golang.org/protobuf/types/known/emptypb\370\001\001\242\002\003GPB\252\002\036Google.Protobuf.WellKnownTypes'
+  _globals['_EMPTY']._serialized_start=48
+  _globals['_EMPTY']._serialized_end=55
+# @@protoc_insertion_point(module_scope)

.venv/lib/python3.11/site-packages/google/protobuf/field_mask_pb2.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: google/protobuf/field_mask.proto
+# Protobuf Python Version: 5.29.3
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    5,
+    29,
+    3,
+    '',
+    'google/protobuf/field_mask.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n google/protobuf/field_mask.proto\x12\x0fgoogle.protobuf\"!\n\tFieldMask\x12\x14\n\x05paths\x18\x01 \x03(\tR\x05pathsB\x85\x01\n\x13\x63om.google.protobufB\x0e\x46ieldMaskProtoP\x01Z2google.golang.org/protobuf/types/known/fieldmaskpb\xf8\x01\x01\xa2\x02\x03GPB\xaa\x02\x1eGoogle.Protobuf.WellKnownTypesb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'google.protobuf.field_mask_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  _globals['DESCRIPTOR']._loaded_options = None
+  _globals['DESCRIPTOR']._serialized_options = b'\n\023com.google.protobufB\016FieldMaskProtoP\001Z2google.golang.org/protobuf/types/known/fieldmaskpb\370\001\001\242\002\003GPB\252\002\036Google.Protobuf.WellKnownTypes'
+  _globals['_FIELDMASK']._serialized_start=53
+  _globals['_FIELDMASK']._serialized_end=86
+# @@protoc_insertion_point(module_scope)

.venv/lib/python3.11/site-packages/google/protobuf/internal/_parameterized.py

@@ -0,0 +1,420 @@
+#! /usr/bin/env python
+#
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+"""Adds support for parameterized tests to Python's unittest TestCase class.
+
+A parameterized test is a method in a test case that is invoked with different
+argument tuples.
+
+A simple example:
+
+  class AdditionExample(_parameterized.TestCase):
+    @_parameterized.parameters(
+       (1, 2, 3),
+       (4, 5, 9),
+       (1, 1, 3))
+    def testAddition(self, op1, op2, result):
+      self.assertEqual(result, op1 + op2)
+
+
+Each invocation is a separate test case and properly isolated just
+like a normal test method, with its own setUp/tearDown cycle. In the
+example above, there are three separate testcases, one of which will
+fail due to an assertion error (1 + 1 != 3).
+
+Parameters for individual test cases can be tuples (with positional parameters)
+or dictionaries (with named parameters):
+
+  class AdditionExample(_parameterized.TestCase):
+    @_parameterized.parameters(
+       {'op1': 1, 'op2': 2, 'result': 3},
+       {'op1': 4, 'op2': 5, 'result': 9},
+    )
+    def testAddition(self, op1, op2, result):
+      self.assertEqual(result, op1 + op2)
+
+If a parameterized test fails, the error message will show the
+original test name (which is modified internally) and the arguments
+for the specific invocation, which are part of the string returned by
+the shortDescription() method on test cases.
+
+The id method of the test, used internally by the unittest framework,
+is also modified to show the arguments. To make sure that test names
+stay the same across several invocations, object representations like
+
+  >>> class Foo(object):
+  ...  pass
+  >>> repr(Foo())
+  '<__main__.Foo object at 0x23d8610>'
+
+are turned into '<__main__.Foo>'. For even more descriptive names,
+especially in test logs, you can use the named_parameters decorator. In
+this case, only tuples are supported, and the first parameters has to
+be a string (or an object that returns an apt name when converted via
+str()):
+
+  class NamedExample(_parameterized.TestCase):
+    @_parameterized.named_parameters(
+       ('Normal', 'aa', 'aaa', True),
+       ('EmptyPrefix', '', 'abc', True),
+       ('BothEmpty', '', '', True))
+    def testStartsWith(self, prefix, string, result):
+      self.assertEqual(result, strings.startswith(prefix))
+
+Named tests also have the benefit that they can be run individually
+from the command line:
+
+  $ testmodule.py NamedExample.testStartsWithNormal
+  .
+  --------------------------------------------------------------------
+  Ran 1 test in 0.000s
+
+  OK
+
+Parameterized Classes
+=====================
+If invocation arguments are shared across test methods in a single
+TestCase class, instead of decorating all test methods
+individually, the class itself can be decorated:
+
+  @_parameterized.parameters(
+    (1, 2, 3)
+    (4, 5, 9))
+  class ArithmeticTest(_parameterized.TestCase):
+    def testAdd(self, arg1, arg2, result):
+      self.assertEqual(arg1 + arg2, result)
+
+    def testSubtract(self, arg2, arg2, result):
+      self.assertEqual(result - arg1, arg2)
+
+Inputs from Iterables
+=====================
+If parameters should be shared across several test cases, or are dynamically
+created from other sources, a single non-tuple iterable can be passed into
+the decorator. This iterable will be used to obtain the test cases:
+
+  class AdditionExample(_parameterized.TestCase):
+    @_parameterized.parameters(
+      c.op1, c.op2, c.result for c in testcases
+    )
+    def testAddition(self, op1, op2, result):
+      self.assertEqual(result, op1 + op2)
+
+
+Single-Argument Test Methods
+============================
+If a test method takes only one argument, the single argument does not need to
+be wrapped into a tuple:
+
+  class NegativeNumberExample(_parameterized.TestCase):
+    @_parameterized.parameters(
+       -1, -3, -4, -5
+    )
+    def testIsNegative(self, arg):
+      self.assertTrue(IsNegative(arg))
+"""
+
+__author__ = 'tmarek@google.com (Torsten Marek)'
+
+import functools
+import re
+import types
+import unittest
+import uuid
+
+try:
+  # Since python 3
+  import collections.abc as collections_abc
+except ImportError:
+  # Won't work after python 3.8
+  import collections as collections_abc
+
+ADDR_RE = re.compile(r'\<([a-zA-Z0-9_\-\.]+) object at 0x[a-fA-F0-9]+\>')
+_SEPARATOR = uuid.uuid1().hex
+_FIRST_ARG = object()
+_ARGUMENT_REPR = object()
+
+
+def _CleanRepr(obj):
+  return ADDR_RE.sub(r'<\1>', repr(obj))
+
+
+# Helper function formerly from the unittest module, removed from it in
+# Python 2.7.
+def _StrClass(cls):
+  return '%s.%s' % (cls.__module__, cls.__name__)
+
+
+def _NonStringIterable(obj):
+  return (isinstance(obj, collections_abc.Iterable) and
+          not isinstance(obj, str))
+
+
+def _FormatParameterList(testcase_params):
+  if isinstance(testcase_params, collections_abc.Mapping):
+    return ', '.join('%s=%s' % (argname, _CleanRepr(value))
+                     for argname, value in testcase_params.items())
+  elif _NonStringIterable(testcase_params):
+    return ', '.join(map(_CleanRepr, testcase_params))
+  else:
+    return _FormatParameterList((testcase_params,))
+
+
+class _ParameterizedTestIter(object):
+  """Callable and iterable class for producing new test cases."""
+
+  def __init__(self, test_method, testcases, naming_type):
+    """Returns concrete test functions for a test and a list of parameters.
+
+    The naming_type is used to determine the name of the concrete
+    functions as reported by the unittest framework. If naming_type is
+    _FIRST_ARG, the testcases must be tuples, and the first element must
+    have a string representation that is a valid Python identifier.
+
+    Args:
+      test_method: The decorated test method.
+      testcases: (list of tuple/dict) A list of parameter
+                 tuples/dicts for individual test invocations.
+      naming_type: The test naming type, either _NAMED or _ARGUMENT_REPR.
+    """
+    self._test_method = test_method
+    self.testcases = testcases
+    self._naming_type = naming_type
+
+  def __call__(self, *args, **kwargs):
+    raise RuntimeError('You appear to be running a parameterized test case '
+                       'without having inherited from parameterized.'
+                       'TestCase. This is bad because none of '
+                       'your test cases are actually being run.')
+
+  def __iter__(self):
+    test_method = self._test_method
+    naming_type = self._naming_type
+
+    def MakeBoundParamTest(testcase_params):
+      @functools.wraps(test_method)
+      def BoundParamTest(self):
+        if isinstance(testcase_params, collections_abc.Mapping):
+          test_method(self, **testcase_params)
+        elif _NonStringIterable(testcase_params):
+          test_method(self, *testcase_params)
+        else:
+          test_method(self, testcase_params)
+
+      if naming_type is _FIRST_ARG:
+        # Signal the metaclass that the name of the test function is unique
+        # and descriptive.
+        BoundParamTest.__x_use_name__ = True
+        BoundParamTest.__name__ += str(testcase_params[0])
+        testcase_params = testcase_params[1:]
+      elif naming_type is _ARGUMENT_REPR:
+        # __x_extra_id__ is used to pass naming information to the __new__
+        # method of TestGeneratorMetaclass.
+        # The metaclass will make sure to create a unique, but nondescriptive
+        # name for this test.
+        BoundParamTest.__x_extra_id__ = '(%s)' % (
+            _FormatParameterList(testcase_params),)
+      else:
+        raise RuntimeError('%s is not a valid naming type.' % (naming_type,))
+
+      BoundParamTest.__doc__ = '%s(%s)' % (
+          BoundParamTest.__name__, _FormatParameterList(testcase_params))
+      if test_method.__doc__:
+        BoundParamTest.__doc__ += '\n%s' % (test_method.__doc__,)
+      return BoundParamTest
+    return (MakeBoundParamTest(c) for c in self.testcases)
+
+
+def _IsSingletonList(testcases):
+  """True iff testcases contains only a single non-tuple element."""
+  return len(testcases) == 1 and not isinstance(testcases[0], tuple)
+
+
+def _ModifyClass(class_object, testcases, naming_type):
+  assert not getattr(class_object, '_id_suffix', None), (
+      'Cannot add parameters to %s,'
+      ' which already has parameterized methods.' % (class_object,))
+  class_object._id_suffix = id_suffix = {}
+  # We change the size of __dict__ while we iterate over it,
+  # which Python 3.x will complain about, so use copy().
+  for name, obj in class_object.__dict__.copy().items():
+    if (name.startswith(unittest.TestLoader.testMethodPrefix)
+        and isinstance(obj, types.FunctionType)):
+      delattr(class_object, name)
+      methods = {}
+      _UpdateClassDictForParamTestCase(
+          methods, id_suffix, name,
+          _ParameterizedTestIter(obj, testcases, naming_type))
+      for name, meth in methods.items():
+        setattr(class_object, name, meth)
+
+
+def _ParameterDecorator(naming_type, testcases):
+  """Implementation of the parameterization decorators.
+
+  Args:
+    naming_type: The naming type.
+    testcases: Testcase parameters.
+
+  Returns:
+    A function for modifying the decorated object.
+  """
+  def _Apply(obj):
+    if isinstance(obj, type):
+      _ModifyClass(
+          obj,
+          list(testcases) if not isinstance(testcases, collections_abc.Sequence)
+          else testcases,
+          naming_type)
+      return obj
+    else:
+      return _ParameterizedTestIter(obj, testcases, naming_type)
+
+  if _IsSingletonList(testcases):
+    assert _NonStringIterable(testcases[0]), (
+        'Single parameter argument must be a non-string iterable')
+    testcases = testcases[0]
+
+  return _Apply
+
+
+def parameters(*testcases):  # pylint: disable=invalid-name
+  """A decorator for creating parameterized tests.
+
+  See the module docstring for a usage example.
+  Args:
+    *testcases: Parameters for the decorated method, either a single
+                iterable, or a list of tuples/dicts/objects (for tests
+                with only one argument).
+
+  Returns:
+     A test generator to be handled by TestGeneratorMetaclass.
+  """
+  return _ParameterDecorator(_ARGUMENT_REPR, testcases)
+
+
+def named_parameters(*testcases):  # pylint: disable=invalid-name
+  """A decorator for creating parameterized tests.
+
+  See the module docstring for a usage example. The first element of
+  each parameter tuple should be a string and will be appended to the
+  name of the test method.
+
+  Args:
+    *testcases: Parameters for the decorated method, either a single
+                iterable, or a list of tuples.
+
+  Returns:
+     A test generator to be handled by TestGeneratorMetaclass.
+  """
+  return _ParameterDecorator(_FIRST_ARG, testcases)
+
+
+class TestGeneratorMetaclass(type):
+  """Metaclass for test cases with test generators.
+
+  A test generator is an iterable in a testcase that produces callables. These
+  callables must be single-argument methods. These methods are injected into
+  the class namespace and the original iterable is removed. If the name of the
+  iterable conforms to the test pattern, the injected methods will be picked
+  up as tests by the unittest framework.
+
+  In general, it is supposed to be used in conjunction with the
+  parameters decorator.
+  """
+
+  def __new__(mcs, class_name, bases, dct):
+    dct['_id_suffix'] = id_suffix = {}
+    for name, obj in dct.copy().items():
+      if (name.startswith(unittest.TestLoader.testMethodPrefix) and
+          _NonStringIterable(obj)):
+        iterator = iter(obj)
+        dct.pop(name)
+        _UpdateClassDictForParamTestCase(dct, id_suffix, name, iterator)
+
+    return type.__new__(mcs, class_name, bases, dct)
+
+
+def _UpdateClassDictForParamTestCase(dct, id_suffix, name, iterator):
+  """Adds individual test cases to a dictionary.
+
+  Args:
+    dct: The target dictionary.
+    id_suffix: The dictionary for mapping names to test IDs.
+    name: The original name of the test case.
+    iterator: The iterator generating the individual test cases.
+  """
+  for idx, func in enumerate(iterator):
+    assert callable(func), 'Test generators must yield callables, got %r' % (
+        func,)
+    if getattr(func, '__x_use_name__', False):
+      new_name = func.__name__
+    else:
+      new_name = '%s%s%d' % (name, _SEPARATOR, idx)
+    assert new_name not in dct, (
+        'Name of parameterized test case "%s" not unique' % (new_name,))
+    dct[new_name] = func
+    id_suffix[new_name] = getattr(func, '__x_extra_id__', '')
+
+
+class TestCase(unittest.TestCase, metaclass=TestGeneratorMetaclass):
+  """Base class for test cases using the parameters decorator."""
+
+  def _OriginalName(self):
+    return self._testMethodName.split(_SEPARATOR)[0]
+
+  def __str__(self):
+    return '%s (%s)' % (self._OriginalName(), _StrClass(self.__class__))
+
+  def id(self):  # pylint: disable=invalid-name
+    """Returns the descriptive ID of the test.
+
+    This is used internally by the unittesting framework to get a name
+    for the test to be used in reports.
+
+    Returns:
+      The test id.
+    """
+    return '%s.%s%s' % (_StrClass(self.__class__),
+                        self._OriginalName(),
+                        self._id_suffix.get(self._testMethodName, ''))
+
+
+def CoopTestCase(other_base_class):
+  """Returns a new base class with a cooperative metaclass base.
+
+  This enables the TestCase to be used in combination
+  with other base classes that have custom metaclasses, such as
+  mox.MoxTestBase.
+
+  Only works with metaclasses that do not override type.__new__.
+
+  Example:
+
+    import google3
+    import mox
+
+    from google.protobuf.internal import _parameterized
+
+    class ExampleTest(parameterized.CoopTestCase(mox.MoxTestBase)):
+      ...
+
+  Args:
+    other_base_class: (class) A test case base class.
+
+  Returns:
+    A new class object.
+  """
+  metaclass = type(
+      'CoopMetaclass',
+      (other_base_class.__metaclass__,
+       TestGeneratorMetaclass), {})
+  return metaclass(
+      'CoopTestCase',
+      (other_base_class, TestCase), {})

.venv/lib/python3.11/site-packages/google/protobuf/internal/containers.py

@@ -0,0 +1,677 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+"""Contains container classes to represent different protocol buffer types.
+
+This file defines container classes which represent categories of protocol
+buffer field types which need extra maintenance. Currently these categories
+are:
+
+-   Repeated scalar fields - These are all repeated fields which aren't
+    composite (e.g. they are of simple types like int32, string, etc).
+-   Repeated composite fields - Repeated fields which are composite. This
+    includes groups and nested messages.
+"""
+
+import collections.abc
+import copy
+import pickle
+from typing import (
+    Any,
+    Iterable,
+    Iterator,
+    List,
+    MutableMapping,
+    MutableSequence,
+    NoReturn,
+    Optional,
+    Sequence,
+    TypeVar,
+    Union,
+    overload,
+)
+
+
+_T = TypeVar('_T')
+_K = TypeVar('_K')
+_V = TypeVar('_V')
+
+
+class BaseContainer(Sequence[_T]):
+  """Base container class."""
+
+  # Minimizes memory usage and disallows assignment to other attributes.
+  __slots__ = ['_message_listener', '_values']
+
+  def __init__(self, message_listener: Any) -> None:
+    """
+    Args:
+      message_listener: A MessageListener implementation.
+        The RepeatedScalarFieldContainer will call this object's
+        Modified() method when it is modified.
+    """
+    self._message_listener = message_listener
+    self._values = []
+
+  @overload
+  def __getitem__(self, key: int) -> _T:
+    ...
+
+  @overload
+  def __getitem__(self, key: slice) -> List[_T]:
+    ...
+
+  def __getitem__(self, key):
+    """Retrieves item by the specified key."""
+    return self._values[key]
+
+  def __len__(self) -> int:
+    """Returns the number of elements in the container."""
+    return len(self._values)
+
+  def __ne__(self, other: Any) -> bool:
+    """Checks if another instance isn't equal to this one."""
+    # The concrete classes should define __eq__.
+    return not self == other
+
+  __hash__ = None
+
+  def __repr__(self) -> str:
+    return repr(self._values)
+
+  def sort(self, *args, **kwargs) -> None:
+    # Continue to support the old sort_function keyword argument.
+    # This is expected to be a rare occurrence, so use LBYL to avoid
+    # the overhead of actually catching KeyError.
+    if 'sort_function' in kwargs:
+      kwargs['cmp'] = kwargs.pop('sort_function')
+    self._values.sort(*args, **kwargs)
+
+  def reverse(self) -> None:
+    self._values.reverse()
+
+
+# TODO: Remove this. BaseContainer does *not* conform to
+# MutableSequence, only its subclasses do.
+collections.abc.MutableSequence.register(BaseContainer)
+
+
+class RepeatedScalarFieldContainer(BaseContainer[_T], MutableSequence[_T]):
+  """Simple, type-checked, list-like container for holding repeated scalars."""
+
+  # Disallows assignment to other attributes.
+  __slots__ = ['_type_checker']
+
+  def __init__(
+      self,
+      message_listener: Any,
+      type_checker: Any,
+  ) -> None:
+    """Args:
+
+      message_listener: A MessageListener implementation. The
+      RepeatedScalarFieldContainer will call this object's Modified() method
+      when it is modified.
+      type_checker: A type_checkers.ValueChecker instance to run on elements
+      inserted into this container.
+    """
+    super().__init__(message_listener)
+    self._type_checker = type_checker
+
+  def append(self, value: _T) -> None:
+    """Appends an item to the list. Similar to list.append()."""
+    self._values.append(self._type_checker.CheckValue(value))
+    if not self._message_listener.dirty:
+      self._message_listener.Modified()
+
+  def insert(self, key: int, value: _T) -> None:
+    """Inserts the item at the specified position. Similar to list.insert()."""
+    self._values.insert(key, self._type_checker.CheckValue(value))
+    if not self._message_listener.dirty:
+      self._message_listener.Modified()
+
+  def extend(self, elem_seq: Iterable[_T]) -> None:
+    """Extends by appending the given iterable. Similar to list.extend()."""
+    elem_seq_iter = iter(elem_seq)
+    new_values = [self._type_checker.CheckValue(elem) for elem in elem_seq_iter]
+    if new_values:
+      self._values.extend(new_values)
+    self._message_listener.Modified()
+
+  def MergeFrom(
+      self,
+      other: Union['RepeatedScalarFieldContainer[_T]', Iterable[_T]],
+  ) -> None:
+    """Appends the contents of another repeated field of the same type to this
+    one. We do not check the types of the individual fields.
+    """
+    self._values.extend(other)
+    self._message_listener.Modified()
+
+  def remove(self, elem: _T):
+    """Removes an item from the list. Similar to list.remove()."""
+    self._values.remove(elem)
+    self._message_listener.Modified()
+
+  def pop(self, key: Optional[int] = -1) -> _T:
+    """Removes and returns an item at a given index. Similar to list.pop()."""
+    value = self._values[key]
+    self.__delitem__(key)
+    return value
+
+  @overload
+  def __setitem__(self, key: int, value: _T) -> None:
+    ...
+
+  @overload
+  def __setitem__(self, key: slice, value: Iterable[_T]) -> None:
+    ...
+
+  def __setitem__(self, key, value) -> None:
+    """Sets the item on the specified position."""
+    if isinstance(key, slice):
+      if key.step is not None:
+        raise ValueError('Extended slices not supported')
+      self._values[key] = map(self._type_checker.CheckValue, value)
+      self._message_listener.Modified()
+    else:
+      self._values[key] = self._type_checker.CheckValue(value)
+      self._message_listener.Modified()
+
+  def __delitem__(self, key: Union[int, slice]) -> None:
+    """Deletes the item at the specified position."""
+    del self._values[key]
+    self._message_listener.Modified()
+
+  def __eq__(self, other: Any) -> bool:
+    """Compares the current instance with another one."""
+    if self is other:
+      return True
+    # Special case for the same type which should be common and fast.
+    if isinstance(other, self.__class__):
+      return other._values == self._values
+    # We are presumably comparing against some other sequence type.
+    return other == self._values
+
+  def __deepcopy__(
+      self,
+      unused_memo: Any = None,
+  ) -> 'RepeatedScalarFieldContainer[_T]':
+    clone = RepeatedScalarFieldContainer(
+        copy.deepcopy(self._message_listener), self._type_checker)
+    clone.MergeFrom(self)
+    return clone
+
+  def __reduce__(self, **kwargs) -> NoReturn:
+    raise pickle.PickleError(
+        "Can't pickle repeated scalar fields, convert to list first")
+
+
+# TODO: Constrain T to be a subtype of Message.
+class RepeatedCompositeFieldContainer(BaseContainer[_T], MutableSequence[_T]):
+  """Simple, list-like container for holding repeated composite fields."""
+
+  # Disallows assignment to other attributes.
+  __slots__ = ['_message_descriptor']
+
+  def __init__(self, message_listener: Any, message_descriptor: Any) -> None:
+    """
+    Note that we pass in a descriptor instead of the generated directly,
+    since at the time we construct a _RepeatedCompositeFieldContainer we
+    haven't yet necessarily initialized the type that will be contained in the
+    container.
+
+    Args:
+      message_listener: A MessageListener implementation.
+        The RepeatedCompositeFieldContainer will call this object's
+        Modified() method when it is modified.
+      message_descriptor: A Descriptor instance describing the protocol type
+        that should be present in this container.  We'll use the
+        _concrete_class field of this descriptor when the client calls add().
+    """
+    super().__init__(message_listener)
+    self._message_descriptor = message_descriptor
+
+  def add(self, **kwargs: Any) -> _T:
+    """Adds a new element at the end of the list and returns it. Keyword
+    arguments may be used to initialize the element.
+    """
+    new_element = self._message_descriptor._concrete_class(**kwargs)
+    new_element._SetListener(self._message_listener)
+    self._values.append(new_element)
+    if not self._message_listener.dirty:
+      self._message_listener.Modified()
+    return new_element
+
+  def append(self, value: _T) -> None:
+    """Appends one element by copying the message."""
+    new_element = self._message_descriptor._concrete_class()
+    new_element._SetListener(self._message_listener)
+    new_element.CopyFrom(value)
+    self._values.append(new_element)
+    if not self._message_listener.dirty:
+      self._message_listener.Modified()
+
+  def insert(self, key: int, value: _T) -> None:
+    """Inserts the item at the specified position by copying."""
+    new_element = self._message_descriptor._concrete_class()
+    new_element._SetListener(self._message_listener)
+    new_element.CopyFrom(value)
+    self._values.insert(key, new_element)
+    if not self._message_listener.dirty:
+      self._message_listener.Modified()
+
+  def extend(self, elem_seq: Iterable[_T]) -> None:
+    """Extends by appending the given sequence of elements of the same type
+
+    as this one, copying each individual message.
+    """
+    message_class = self._message_descriptor._concrete_class
+    listener = self._message_listener
+    values = self._values
+    for message in elem_seq:
+      new_element = message_class()
+      new_element._SetListener(listener)
+      new_element.MergeFrom(message)
+      values.append(new_element)
+    listener.Modified()
+
+  def MergeFrom(
+      self,
+      other: Union['RepeatedCompositeFieldContainer[_T]', Iterable[_T]],
+  ) -> None:
+    """Appends the contents of another repeated field of the same type to this
+    one, copying each individual message.
+    """
+    self.extend(other)
+
+  def remove(self, elem: _T) -> None:
+    """Removes an item from the list. Similar to list.remove()."""
+    self._values.remove(elem)
+    self._message_listener.Modified()
+
+  def pop(self, key: Optional[int] = -1) -> _T:
+    """Removes and returns an item at a given index. Similar to list.pop()."""
+    value = self._values[key]
+    self.__delitem__(key)
+    return value
+
+  @overload
+  def __setitem__(self, key: int, value: _T) -> None:
+    ...
+
+  @overload
+  def __setitem__(self, key: slice, value: Iterable[_T]) -> None:
+    ...
+
+  def __setitem__(self, key, value):
+    # This method is implemented to make RepeatedCompositeFieldContainer
+    # structurally compatible with typing.MutableSequence. It is
+    # otherwise unsupported and will always raise an error.
+    raise TypeError(
+        f'{self.__class__.__name__} object does not support item assignment')
+
+  def __delitem__(self, key: Union[int, slice]) -> None:
+    """Deletes the item at the specified position."""
+    del self._values[key]
+    self._message_listener.Modified()
+
+  def __eq__(self, other: Any) -> bool:
+    """Compares the current instance with another one."""
+    if self is other:
+      return True
+    if not isinstance(other, self.__class__):
+      raise TypeError('Can only compare repeated composite fields against '
+                      'other repeated composite fields.')
+    return self._values == other._values
+
+
+class ScalarMap(MutableMapping[_K, _V]):
+  """Simple, type-checked, dict-like container for holding repeated scalars."""
+
+  # Disallows assignment to other attributes.
+  __slots__ = ['_key_checker', '_value_checker', '_values', '_message_listener',
+               '_entry_descriptor']
+
+  def __init__(
+      self,
+      message_listener: Any,
+      key_checker: Any,
+      value_checker: Any,
+      entry_descriptor: Any,
+  ) -> None:
+    """
+    Args:
+      message_listener: A MessageListener implementation.
+        The ScalarMap will call this object's Modified() method when it
+        is modified.
+      key_checker: A type_checkers.ValueChecker instance to run on keys
+        inserted into this container.
+      value_checker: A type_checkers.ValueChecker instance to run on values
+        inserted into this container.
+      entry_descriptor: The MessageDescriptor of a map entry: key and value.
+    """
+    self._message_listener = message_listener
+    self._key_checker = key_checker
+    self._value_checker = value_checker
+    self._entry_descriptor = entry_descriptor
+    self._values = {}
+
+  def __getitem__(self, key: _K) -> _V:
+    try:
+      return self._values[key]
+    except KeyError:
+      key = self._key_checker.CheckValue(key)
+      val = self._value_checker.DefaultValue()
+      self._values[key] = val
+      return val
+
+  def __contains__(self, item: _K) -> bool:
+    # We check the key's type to match the strong-typing flavor of the API.
+    # Also this makes it easier to match the behavior of the C++ implementation.
+    self._key_checker.CheckValue(item)
+    return item in self._values
+
+  @overload
+  def get(self, key: _K) -> Optional[_V]:
+    ...
+
+  @overload
+  def get(self, key: _K, default: _T) -> Union[_V, _T]:
+    ...
+
+  # We need to override this explicitly, because our defaultdict-like behavior
+  # will make the default implementation (from our base class) always insert
+  # the key.
+  def get(self, key, default=None):
+    if key in self:
+      return self[key]
+    else:
+      return default
+
+  def __setitem__(self, key: _K, value: _V) -> _T:
+    checked_key = self._key_checker.CheckValue(key)
+    checked_value = self._value_checker.CheckValue(value)
+    self._values[checked_key] = checked_value
+    self._message_listener.Modified()
+
+  def __delitem__(self, key: _K) -> None:
+    del self._values[key]
+    self._message_listener.Modified()
+
+  def __len__(self) -> int:
+    return len(self._values)
+
+  def __iter__(self) -> Iterator[_K]:
+    return iter(self._values)
+
+  def __repr__(self) -> str:
+    return repr(self._values)
+
+  def MergeFrom(self, other: 'ScalarMap[_K, _V]') -> None:
+    self._values.update(other._values)
+    self._message_listener.Modified()
+
+  def InvalidateIterators(self) -> None:
+    # It appears that the only way to reliably invalidate iterators to
+    # self._values is to ensure that its size changes.
+    original = self._values
+    self._values = original.copy()
+    original[None] = None
+
+  # This is defined in the abstract base, but we can do it much more cheaply.
+  def clear(self) -> None:
+    self._values.clear()
+    self._message_listener.Modified()
+
+  def GetEntryClass(self) -> Any:
+    return self._entry_descriptor._concrete_class
+
+
+class MessageMap(MutableMapping[_K, _V]):
+  """Simple, type-checked, dict-like container for with submessage values."""
+
+  # Disallows assignment to other attributes.
+  __slots__ = ['_key_checker', '_values', '_message_listener',
+               '_message_descriptor', '_entry_descriptor']
+
+  def __init__(
+      self,
+      message_listener: Any,
+      message_descriptor: Any,
+      key_checker: Any,
+      entry_descriptor: Any,
+  ) -> None:
+    """
+    Args:
+      message_listener: A MessageListener implementation.
+        The ScalarMap will call this object's Modified() method when it
+        is modified.
+      key_checker: A type_checkers.ValueChecker instance to run on keys
+        inserted into this container.
+      value_checker: A type_checkers.ValueChecker instance to run on values
+        inserted into this container.
+      entry_descriptor: The MessageDescriptor of a map entry: key and value.
+    """
+    self._message_listener = message_listener
+    self._message_descriptor = message_descriptor
+    self._key_checker = key_checker
+    self._entry_descriptor = entry_descriptor
+    self._values = {}
+
+  def __getitem__(self, key: _K) -> _V:
+    key = self._key_checker.CheckValue(key)
+    try:
+      return self._values[key]
+    except KeyError:
+      new_element = self._message_descriptor._concrete_class()
+      new_element._SetListener(self._message_listener)
+      self._values[key] = new_element
+      self._message_listener.Modified()
+      return new_element
+
+  def get_or_create(self, key: _K) -> _V:
+    """get_or_create() is an alias for getitem (ie. map[key]).
+
+    Args:
+      key: The key to get or create in the map.
+
+    This is useful in cases where you want to be explicit that the call is
+    mutating the map.  This can avoid lint errors for statements like this
+    that otherwise would appear to be pointless statements:
+
+      msg.my_map[key]
+    """
+    return self[key]
+
+  @overload
+  def get(self, key: _K) -> Optional[_V]:
+    ...
+
+  @overload
+  def get(self, key: _K, default: _T) -> Union[_V, _T]:
+    ...
+
+  # We need to override this explicitly, because our defaultdict-like behavior
+  # will make the default implementation (from our base class) always insert
+  # the key.
+  def get(self, key, default=None):
+    if key in self:
+      return self[key]
+    else:
+      return default
+
+  def __contains__(self, item: _K) -> bool:
+    item = self._key_checker.CheckValue(item)
+    return item in self._values
+
+  def __setitem__(self, key: _K, value: _V) -> NoReturn:
+    raise ValueError('May not set values directly, call my_map[key].foo = 5')
+
+  def __delitem__(self, key: _K) -> None:
+    key = self._key_checker.CheckValue(key)
+    del self._values[key]
+    self._message_listener.Modified()
+
+  def __len__(self) -> int:
+    return len(self._values)
+
+  def __iter__(self) -> Iterator[_K]:
+    return iter(self._values)
+
+  def __repr__(self) -> str:
+    return repr(self._values)
+
+  def MergeFrom(self, other: 'MessageMap[_K, _V]') -> None:
+    # pylint: disable=protected-access
+    for key in other._values:
+      # According to documentation: "When parsing from the wire or when merging,
+      # if there are duplicate map keys the last key seen is used".
+      if key in self:
+        del self[key]
+      self[key].CopyFrom(other[key])
+    # self._message_listener.Modified() not required here, because
+    # mutations to submessages already propagate.
+
+  def InvalidateIterators(self) -> None:
+    # It appears that the only way to reliably invalidate iterators to
+    # self._values is to ensure that its size changes.
+    original = self._values
+    self._values = original.copy()
+    original[None] = None
+
+  # This is defined in the abstract base, but we can do it much more cheaply.
+  def clear(self) -> None:
+    self._values.clear()
+    self._message_listener.Modified()
+
+  def GetEntryClass(self) -> Any:
+    return self._entry_descriptor._concrete_class
+
+
+class _UnknownField:
+  """A parsed unknown field."""
+
+  # Disallows assignment to other attributes.
+  __slots__ = ['_field_number', '_wire_type', '_data']
+
+  def __init__(self, field_number, wire_type, data):
+    self._field_number = field_number
+    self._wire_type = wire_type
+    self._data = data
+    return
+
+  def __lt__(self, other):
+    # pylint: disable=protected-access
+    return self._field_number < other._field_number
+
+  def __eq__(self, other):
+    if self is other:
+      return True
+    # pylint: disable=protected-access
+    return (self._field_number == other._field_number and
+            self._wire_type == other._wire_type and
+            self._data == other._data)
+
+
+class UnknownFieldRef:  # pylint: disable=missing-class-docstring
+
+  def __init__(self, parent, index):
+    self._parent = parent
+    self._index = index
+
+  def _check_valid(self):
+    if not self._parent:
+      raise ValueError('UnknownField does not exist. '
+                       'The parent message might be cleared.')
+    if self._index >= len(self._parent):
+      raise ValueError('UnknownField does not exist. '
+                       'The parent message might be cleared.')
+
+  @property
+  def field_number(self):
+    self._check_valid()
+    # pylint: disable=protected-access
+    return self._parent._internal_get(self._index)._field_number
+
+  @property
+  def wire_type(self):
+    self._check_valid()
+    # pylint: disable=protected-access
+    return self._parent._internal_get(self._index)._wire_type
+
+  @property
+  def data(self):
+    self._check_valid()
+    # pylint: disable=protected-access
+    return self._parent._internal_get(self._index)._data
+
+
+class UnknownFieldSet:
+  """UnknownField container"""
+
+  # Disallows assignment to other attributes.
+  __slots__ = ['_values']
+
+  def __init__(self):
+    self._values = []
+
+  def __getitem__(self, index):
+    if self._values is None:
+      raise ValueError('UnknownFields does not exist. '
+                       'The parent message might be cleared.')
+    size = len(self._values)
+    if index < 0:
+      index += size
+    if index < 0 or index >= size:
+      raise IndexError('index %d out of range'.index)
+
+    return UnknownFieldRef(self, index)
+
+  def _internal_get(self, index):
+    return self._values[index]
+
+  def __len__(self):
+    if self._values is None:
+      raise ValueError('UnknownFields does not exist. '
+                       'The parent message might be cleared.')
+    return len(self._values)
+
+  def _add(self, field_number, wire_type, data):
+    unknown_field = _UnknownField(field_number, wire_type, data)
+    self._values.append(unknown_field)
+    return unknown_field
+
+  def __iter__(self):
+    for i in range(len(self)):
+      yield UnknownFieldRef(self, i)
+
+  def _extend(self, other):
+    if other is None:
+      return
+    # pylint: disable=protected-access
+    self._values.extend(other._values)
+
+  def __eq__(self, other):
+    if self is other:
+      return True
+    # Sort unknown fields because their order shouldn't
+    # affect equality test.
+    values = list(self._values)
+    if other is None:
+      return not values
+    values.sort()
+    # pylint: disable=protected-access
+    other_values = sorted(other._values)
+    return values == other_values
+
+  def _clear(self):
+    for value in self._values:
+      # pylint: disable=protected-access
+      if isinstance(value._data, UnknownFieldSet):
+        value._data._clear()  # pylint: disable=protected-access
+    self._values = None

.venv/lib/python3.11/site-packages/google/protobuf/internal/encoder.py

@@ -0,0 +1,806 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+"""Code for encoding protocol message primitives.
+
+Contains the logic for encoding every logical protocol field type
+into one of the 5 physical wire types.
+
+This code is designed to push the Python interpreter's performance to the
+limits.
+
+The basic idea is that at startup time, for every field (i.e. every
+FieldDescriptor) we construct two functions:  a "sizer" and an "encoder".  The
+sizer takes a value of this field's type and computes its byte size.  The
+encoder takes a writer function and a value.  It encodes the value into byte
+strings and invokes the writer function to write those strings.  Typically the
+writer function is the write() method of a BytesIO.
+
+We try to do as much work as possible when constructing the writer and the
+sizer rather than when calling them.  In particular:
+* We copy any needed global functions to local variables, so that we do not need
+  to do costly global table lookups at runtime.
+* Similarly, we try to do any attribute lookups at startup time if possible.
+* Every field's tag is encoded to bytes at startup, since it can't change at
+  runtime.
+* Whatever component of the field size we can compute at startup, we do.
+* We *avoid* sharing code if doing so would make the code slower and not sharing
+  does not burden us too much.  For example, encoders for repeated fields do
+  not just call the encoders for singular fields in a loop because this would
+  add an extra function call overhead for every loop iteration; instead, we
+  manually inline the single-value encoder into the loop.
+* If a Python function lacks a return statement, Python actually generates
+  instructions to pop the result of the last statement off the stack, push
+  None onto the stack, and then return that.  If we really don't care what
+  value is returned, then we can save two instructions by returning the
+  result of the last statement.  It looks funny but it helps.
+* We assume that type and bounds checking has happened at a higher level.
+"""
+
+__author__ = 'kenton@google.com (Kenton Varda)'
+
+import struct
+
+from google.protobuf.internal import wire_format
+
+
+# This will overflow and thus become IEEE-754 "infinity".  We would use
+# "float('inf')" but it doesn't work on Windows pre-Python-2.6.
+_POS_INF = 1e10000
+_NEG_INF = -_POS_INF
+
+
+def _VarintSize(value):
+  """Compute the size of a varint value."""
+  if value <= 0x7f: return 1
+  if value <= 0x3fff: return 2
+  if value <= 0x1fffff: return 3
+  if value <= 0xfffffff: return 4
+  if value <= 0x7ffffffff: return 5
+  if value <= 0x3ffffffffff: return 6
+  if value <= 0x1ffffffffffff: return 7
+  if value <= 0xffffffffffffff: return 8
+  if value <= 0x7fffffffffffffff: return 9
+  return 10
+
+
+def _SignedVarintSize(value):
+  """Compute the size of a signed varint value."""
+  if value < 0: return 10
+  if value <= 0x7f: return 1
+  if value <= 0x3fff: return 2
+  if value <= 0x1fffff: return 3
+  if value <= 0xfffffff: return 4
+  if value <= 0x7ffffffff: return 5
+  if value <= 0x3ffffffffff: return 6
+  if value <= 0x1ffffffffffff: return 7
+  if value <= 0xffffffffffffff: return 8
+  if value <= 0x7fffffffffffffff: return 9
+  return 10
+
+
+def _TagSize(field_number):
+  """Returns the number of bytes required to serialize a tag with this field
+  number."""
+  # Just pass in type 0, since the type won't affect the tag+type size.
+  return _VarintSize(wire_format.PackTag(field_number, 0))
+
+
+# --------------------------------------------------------------------
+# In this section we define some generic sizers.  Each of these functions
+# takes parameters specific to a particular field type, e.g. int32 or fixed64.
+# It returns another function which in turn takes parameters specific to a
+# particular field, e.g. the field number and whether it is repeated or packed.
+# Look at the next section to see how these are used.
+
+
+def _SimpleSizer(compute_value_size):
+  """A sizer which uses the function compute_value_size to compute the size of
+  each value.  Typically compute_value_size is _VarintSize."""
+
+  def SpecificSizer(field_number, is_repeated, is_packed):
+    tag_size = _TagSize(field_number)
+    if is_packed:
+      local_VarintSize = _VarintSize
+      def PackedFieldSize(value):
+        result = 0
+        for element in value:
+          result += compute_value_size(element)
+        return result + local_VarintSize(result) + tag_size
+      return PackedFieldSize
+    elif is_repeated:
+      def RepeatedFieldSize(value):
+        result = tag_size * len(value)
+        for element in value:
+          result += compute_value_size(element)
+        return result
+      return RepeatedFieldSize
+    else:
+      def FieldSize(value):
+        return tag_size + compute_value_size(value)
+      return FieldSize
+
+  return SpecificSizer
+
+
+def _ModifiedSizer(compute_value_size, modify_value):
+  """Like SimpleSizer, but modify_value is invoked on each value before it is
+  passed to compute_value_size.  modify_value is typically ZigZagEncode."""
+
+  def SpecificSizer(field_number, is_repeated, is_packed):
+    tag_size = _TagSize(field_number)
+    if is_packed:
+      local_VarintSize = _VarintSize
+      def PackedFieldSize(value):
+        result = 0
+        for element in value:
+          result += compute_value_size(modify_value(element))
+        return result + local_VarintSize(result) + tag_size
+      return PackedFieldSize
+    elif is_repeated:
+      def RepeatedFieldSize(value):
+        result = tag_size * len(value)
+        for element in value:
+          result += compute_value_size(modify_value(element))
+        return result
+      return RepeatedFieldSize
+    else:
+      def FieldSize(value):
+        return tag_size + compute_value_size(modify_value(value))
+      return FieldSize
+
+  return SpecificSizer
+
+
+def _FixedSizer(value_size):
+  """Like _SimpleSizer except for a fixed-size field.  The input is the size
+  of one value."""
+
+  def SpecificSizer(field_number, is_repeated, is_packed):
+    tag_size = _TagSize(field_number)
+    if is_packed:
+      local_VarintSize = _VarintSize
+      def PackedFieldSize(value):
+        result = len(value) * value_size
+        return result + local_VarintSize(result) + tag_size
+      return PackedFieldSize
+    elif is_repeated:
+      element_size = value_size + tag_size
+      def RepeatedFieldSize(value):
+        return len(value) * element_size
+      return RepeatedFieldSize
+    else:
+      field_size = value_size + tag_size
+      def FieldSize(value):
+        return field_size
+      return FieldSize
+
+  return SpecificSizer
+
+
+# ====================================================================
+# Here we declare a sizer constructor for each field type.  Each "sizer
+# constructor" is a function that takes (field_number, is_repeated, is_packed)
+# as parameters and returns a sizer, which in turn takes a field value as
+# a parameter and returns its encoded size.
+
+
+Int32Sizer = Int64Sizer = EnumSizer = _SimpleSizer(_SignedVarintSize)
+
+UInt32Sizer = UInt64Sizer = _SimpleSizer(_VarintSize)
+
+SInt32Sizer = SInt64Sizer = _ModifiedSizer(
+    _SignedVarintSize, wire_format.ZigZagEncode)
+
+Fixed32Sizer = SFixed32Sizer = FloatSizer  = _FixedSizer(4)
+Fixed64Sizer = SFixed64Sizer = DoubleSizer = _FixedSizer(8)
+
+BoolSizer = _FixedSizer(1)
+
+
+def StringSizer(field_number, is_repeated, is_packed):
+  """Returns a sizer for a string field."""
+
+  tag_size = _TagSize(field_number)
+  local_VarintSize = _VarintSize
+  local_len = len
+  assert not is_packed
+  if is_repeated:
+    def RepeatedFieldSize(value):
+      result = tag_size * len(value)
+      for element in value:
+        l = local_len(element.encode('utf-8'))
+        result += local_VarintSize(l) + l
+      return result
+    return RepeatedFieldSize
+  else:
+    def FieldSize(value):
+      l = local_len(value.encode('utf-8'))
+      return tag_size + local_VarintSize(l) + l
+    return FieldSize
+
+
+def BytesSizer(field_number, is_repeated, is_packed):
+  """Returns a sizer for a bytes field."""
+
+  tag_size = _TagSize(field_number)
+  local_VarintSize = _VarintSize
+  local_len = len
+  assert not is_packed
+  if is_repeated:
+    def RepeatedFieldSize(value):
+      result = tag_size * len(value)
+      for element in value:
+        l = local_len(element)
+        result += local_VarintSize(l) + l
+      return result
+    return RepeatedFieldSize
+  else:
+    def FieldSize(value):
+      l = local_len(value)
+      return tag_size + local_VarintSize(l) + l
+    return FieldSize
+
+
+def GroupSizer(field_number, is_repeated, is_packed):
+  """Returns a sizer for a group field."""
+
+  tag_size = _TagSize(field_number) * 2
+  assert not is_packed
+  if is_repeated:
+    def RepeatedFieldSize(value):
+      result = tag_size * len(value)
+      for element in value:
+        result += element.ByteSize()
+      return result
+    return RepeatedFieldSize
+  else:
+    def FieldSize(value):
+      return tag_size + value.ByteSize()
+    return FieldSize
+
+
+def MessageSizer(field_number, is_repeated, is_packed):
+  """Returns a sizer for a message field."""
+
+  tag_size = _TagSize(field_number)
+  local_VarintSize = _VarintSize
+  assert not is_packed
+  if is_repeated:
+    def RepeatedFieldSize(value):
+      result = tag_size * len(value)
+      for element in value:
+        l = element.ByteSize()
+        result += local_VarintSize(l) + l
+      return result
+    return RepeatedFieldSize
+  else:
+    def FieldSize(value):
+      l = value.ByteSize()
+      return tag_size + local_VarintSize(l) + l
+    return FieldSize
+
+
+# --------------------------------------------------------------------
+# MessageSet is special: it needs custom logic to compute its size properly.
+
+
+def MessageSetItemSizer(field_number):
+  """Returns a sizer for extensions of MessageSet.
+
+  The message set message looks like this:
+    message MessageSet {
+      repeated group Item = 1 {
+        required int32 type_id = 2;
+        required string message = 3;
+      }
+    }
+  """
+  static_size = (_TagSize(1) * 2 + _TagSize(2) + _VarintSize(field_number) +
+                 _TagSize(3))
+  local_VarintSize = _VarintSize
+
+  def FieldSize(value):
+    l = value.ByteSize()
+    return static_size + local_VarintSize(l) + l
+
+  return FieldSize
+
+
+# --------------------------------------------------------------------
+# Map is special: it needs custom logic to compute its size properly.
+
+
+def MapSizer(field_descriptor, is_message_map):
+  """Returns a sizer for a map field."""
+
+  # Can't look at field_descriptor.message_type._concrete_class because it may
+  # not have been initialized yet.
+  message_type = field_descriptor.message_type
+  message_sizer = MessageSizer(field_descriptor.number, False, False)
+
+  def FieldSize(map_value):
+    total = 0
+    for key in map_value:
+      value = map_value[key]
+      # It's wasteful to create the messages and throw them away one second
+      # later since we'll do the same for the actual encode.  But there's not an
+      # obvious way to avoid this within the current design without tons of code
+      # duplication. For message map, value.ByteSize() should be called to
+      # update the status.
+      entry_msg = message_type._concrete_class(key=key, value=value)
+      total += message_sizer(entry_msg)
+      if is_message_map:
+        value.ByteSize()
+    return total
+
+  return FieldSize
+
+# ====================================================================
+# Encoders!
+
+
+def _VarintEncoder():
+  """Return an encoder for a basic varint value (does not include tag)."""
+
+  local_int2byte = struct.Struct('>B').pack
+
+  def EncodeVarint(write, value, unused_deterministic=None):
+    bits = value & 0x7f
+    value >>= 7
+    while value:
+      write(local_int2byte(0x80|bits))
+      bits = value & 0x7f
+      value >>= 7
+    return write(local_int2byte(bits))
+
+  return EncodeVarint
+
+
+def _SignedVarintEncoder():
+  """Return an encoder for a basic signed varint value (does not include
+  tag)."""
+
+  local_int2byte = struct.Struct('>B').pack
+
+  def EncodeSignedVarint(write, value, unused_deterministic=None):
+    if value < 0:
+      value += (1 << 64)
+    bits = value & 0x7f
+    value >>= 7
+    while value:
+      write(local_int2byte(0x80|bits))
+      bits = value & 0x7f
+      value >>= 7
+    return write(local_int2byte(bits))
+
+  return EncodeSignedVarint
+
+
+_EncodeVarint = _VarintEncoder()
+_EncodeSignedVarint = _SignedVarintEncoder()
+
+
+def _VarintBytes(value):
+  """Encode the given integer as a varint and return the bytes.  This is only
+  called at startup time so it doesn't need to be fast."""
+
+  pieces = []
+  _EncodeVarint(pieces.append, value, True)
+  return b"".join(pieces)
+
+
+def TagBytes(field_number, wire_type):
+  """Encode the given tag and return the bytes.  Only called at startup."""
+
+  return bytes(_VarintBytes(wire_format.PackTag(field_number, wire_type)))
+
+# --------------------------------------------------------------------
+# As with sizers (see above), we have a number of common encoder
+# implementations.
+
+
+def _SimpleEncoder(wire_type, encode_value, compute_value_size):
+  """Return a constructor for an encoder for fields of a particular type.
+
+  Args:
+      wire_type:  The field's wire type, for encoding tags.
+      encode_value:  A function which encodes an individual value, e.g.
+        _EncodeVarint().
+      compute_value_size:  A function which computes the size of an individual
+        value, e.g. _VarintSize().
+  """
+
+  def SpecificEncoder(field_number, is_repeated, is_packed):
+    if is_packed:
+      tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED)
+      local_EncodeVarint = _EncodeVarint
+      def EncodePackedField(write, value, deterministic):
+        write(tag_bytes)
+        size = 0
+        for element in value:
+          size += compute_value_size(element)
+        local_EncodeVarint(write, size, deterministic)
+        for element in value:
+          encode_value(write, element, deterministic)
+      return EncodePackedField
+    elif is_repeated:
+      tag_bytes = TagBytes(field_number, wire_type)
+      def EncodeRepeatedField(write, value, deterministic):
+        for element in value:
+          write(tag_bytes)
+          encode_value(write, element, deterministic)
+      return EncodeRepeatedField
+    else:
+      tag_bytes = TagBytes(field_number, wire_type)
+      def EncodeField(write, value, deterministic):
+        write(tag_bytes)
+        return encode_value(write, value, deterministic)
+      return EncodeField
+
+  return SpecificEncoder
+
+
+def _ModifiedEncoder(wire_type, encode_value, compute_value_size, modify_value):
+  """Like SimpleEncoder but additionally invokes modify_value on every value
+  before passing it to encode_value.  Usually modify_value is ZigZagEncode."""
+
+  def SpecificEncoder(field_number, is_repeated, is_packed):
+    if is_packed:
+      tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED)
+      local_EncodeVarint = _EncodeVarint
+      def EncodePackedField(write, value, deterministic):
+        write(tag_bytes)
+        size = 0
+        for element in value:
+          size += compute_value_size(modify_value(element))
+        local_EncodeVarint(write, size, deterministic)
+        for element in value:
+          encode_value(write, modify_value(element), deterministic)
+      return EncodePackedField
+    elif is_repeated:
+      tag_bytes = TagBytes(field_number, wire_type)
+      def EncodeRepeatedField(write, value, deterministic):
+        for element in value:
+          write(tag_bytes)
+          encode_value(write, modify_value(element), deterministic)
+      return EncodeRepeatedField
+    else:
+      tag_bytes = TagBytes(field_number, wire_type)
+      def EncodeField(write, value, deterministic):
+        write(tag_bytes)
+        return encode_value(write, modify_value(value), deterministic)
+      return EncodeField
+
+  return SpecificEncoder
+
+
+def _StructPackEncoder(wire_type, format):
+  """Return a constructor for an encoder for a fixed-width field.
+
+  Args:
+      wire_type:  The field's wire type, for encoding tags.
+      format:  The format string to pass to struct.pack().
+  """
+
+  value_size = struct.calcsize(format)
+
+  def SpecificEncoder(field_number, is_repeated, is_packed):
+    local_struct_pack = struct.pack
+    if is_packed:
+      tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED)
+      local_EncodeVarint = _EncodeVarint
+      def EncodePackedField(write, value, deterministic):
+        write(tag_bytes)
+        local_EncodeVarint(write, len(value) * value_size, deterministic)
+        for element in value:
+          write(local_struct_pack(format, element))
+      return EncodePackedField
+    elif is_repeated:
+      tag_bytes = TagBytes(field_number, wire_type)
+      def EncodeRepeatedField(write, value, unused_deterministic=None):
+        for element in value:
+          write(tag_bytes)
+          write(local_struct_pack(format, element))
+      return EncodeRepeatedField
+    else:
+      tag_bytes = TagBytes(field_number, wire_type)
+      def EncodeField(write, value, unused_deterministic=None):
+        write(tag_bytes)
+        return write(local_struct_pack(format, value))
+      return EncodeField
+
+  return SpecificEncoder
+
+
+def _FloatingPointEncoder(wire_type, format):
+  """Return a constructor for an encoder for float fields.
+
+  This is like StructPackEncoder, but catches errors that may be due to
+  passing non-finite floating-point values to struct.pack, and makes a
+  second attempt to encode those values.
+
+  Args:
+      wire_type:  The field's wire type, for encoding tags.
+      format:  The format string to pass to struct.pack().
+  """
+
+  value_size = struct.calcsize(format)
+  if value_size == 4:
+    def EncodeNonFiniteOrRaise(write, value):
+      # Remember that the serialized form uses little-endian byte order.
+      if value == _POS_INF:
+        write(b'\x00\x00\x80\x7F')
+      elif value == _NEG_INF:
+        write(b'\x00\x00\x80\xFF')
+      elif value != value:           # NaN
+        write(b'\x00\x00\xC0\x7F')
+      else:
+        raise
+  elif value_size == 8:
+    def EncodeNonFiniteOrRaise(write, value):
+      if value == _POS_INF:
+        write(b'\x00\x00\x00\x00\x00\x00\xF0\x7F')
+      elif value == _NEG_INF:
+        write(b'\x00\x00\x00\x00\x00\x00\xF0\xFF')
+      elif value != value:                         # NaN
+        write(b'\x00\x00\x00\x00\x00\x00\xF8\x7F')
+      else:
+        raise
+  else:
+    raise ValueError('Can\'t encode floating-point values that are '
+                     '%d bytes long (only 4 or 8)' % value_size)
+
+  def SpecificEncoder(field_number, is_repeated, is_packed):
+    local_struct_pack = struct.pack
+    if is_packed:
+      tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED)
+      local_EncodeVarint = _EncodeVarint
+      def EncodePackedField(write, value, deterministic):
+        write(tag_bytes)
+        local_EncodeVarint(write, len(value) * value_size, deterministic)
+        for element in value:
+          # This try/except block is going to be faster than any code that
+          # we could write to check whether element is finite.
+          try:
+            write(local_struct_pack(format, element))
+          except SystemError:
+            EncodeNonFiniteOrRaise(write, element)
+      return EncodePackedField
+    elif is_repeated:
+      tag_bytes = TagBytes(field_number, wire_type)
+      def EncodeRepeatedField(write, value, unused_deterministic=None):
+        for element in value:
+          write(tag_bytes)
+          try:
+            write(local_struct_pack(format, element))
+          except SystemError:
+            EncodeNonFiniteOrRaise(write, element)
+      return EncodeRepeatedField
+    else:
+      tag_bytes = TagBytes(field_number, wire_type)
+      def EncodeField(write, value, unused_deterministic=None):
+        write(tag_bytes)
+        try:
+          write(local_struct_pack(format, value))
+        except SystemError:
+          EncodeNonFiniteOrRaise(write, value)
+      return EncodeField
+
+  return SpecificEncoder
+
+
+# ====================================================================
+# Here we declare an encoder constructor for each field type.  These work
+# very similarly to sizer constructors, described earlier.
+
+
+Int32Encoder = Int64Encoder = EnumEncoder = _SimpleEncoder(
+    wire_format.WIRETYPE_VARINT, _EncodeSignedVarint, _SignedVarintSize)
+
+UInt32Encoder = UInt64Encoder = _SimpleEncoder(
+    wire_format.WIRETYPE_VARINT, _EncodeVarint, _VarintSize)
+
+SInt32Encoder = SInt64Encoder = _ModifiedEncoder(
+    wire_format.WIRETYPE_VARINT, _EncodeVarint, _VarintSize,
+    wire_format.ZigZagEncode)
+
+# Note that Python conveniently guarantees that when using the '<' prefix on
+# formats, they will also have the same size across all platforms (as opposed
+# to without the prefix, where their sizes depend on the C compiler's basic
+# type sizes).
+Fixed32Encoder  = _StructPackEncoder(wire_format.WIRETYPE_FIXED32, '<I')
+Fixed64Encoder  = _StructPackEncoder(wire_format.WIRETYPE_FIXED64, '<Q')
+SFixed32Encoder = _StructPackEncoder(wire_format.WIRETYPE_FIXED32, '<i')
+SFixed64Encoder = _StructPackEncoder(wire_format.WIRETYPE_FIXED64, '<q')
+FloatEncoder    = _FloatingPointEncoder(wire_format.WIRETYPE_FIXED32, '<f')
+DoubleEncoder   = _FloatingPointEncoder(wire_format.WIRETYPE_FIXED64, '<d')
+
+
+def BoolEncoder(field_number, is_repeated, is_packed):
+  """Returns an encoder for a boolean field."""
+
+  false_byte = b'\x00'
+  true_byte = b'\x01'
+  if is_packed:
+    tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED)
+    local_EncodeVarint = _EncodeVarint
+    def EncodePackedField(write, value, deterministic):
+      write(tag_bytes)
+      local_EncodeVarint(write, len(value), deterministic)
+      for element in value:
+        if element:
+          write(true_byte)
+        else:
+          write(false_byte)
+    return EncodePackedField
+  elif is_repeated:
+    tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_VARINT)
+    def EncodeRepeatedField(write, value, unused_deterministic=None):
+      for element in value:
+        write(tag_bytes)
+        if element:
+          write(true_byte)
+        else:
+          write(false_byte)
+    return EncodeRepeatedField
+  else:
+    tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_VARINT)
+    def EncodeField(write, value, unused_deterministic=None):
+      write(tag_bytes)
+      if value:
+        return write(true_byte)
+      return write(false_byte)
+    return EncodeField
+
+
+def StringEncoder(field_number, is_repeated, is_packed):
+  """Returns an encoder for a string field."""
+
+  tag = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED)
+  local_EncodeVarint = _EncodeVarint
+  local_len = len
+  assert not is_packed
+  if is_repeated:
+    def EncodeRepeatedField(write, value, deterministic):
+      for element in value:
+        encoded = element.encode('utf-8')
+        write(tag)
+        local_EncodeVarint(write, local_len(encoded), deterministic)
+        write(encoded)
+    return EncodeRepeatedField
+  else:
+    def EncodeField(write, value, deterministic):
+      encoded = value.encode('utf-8')
+      write(tag)
+      local_EncodeVarint(write, local_len(encoded), deterministic)
+      return write(encoded)
+    return EncodeField
+
+
+def BytesEncoder(field_number, is_repeated, is_packed):
+  """Returns an encoder for a bytes field."""
+
+  tag = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED)
+  local_EncodeVarint = _EncodeVarint
+  local_len = len
+  assert not is_packed
+  if is_repeated:
+    def EncodeRepeatedField(write, value, deterministic):
+      for element in value:
+        write(tag)
+        local_EncodeVarint(write, local_len(element), deterministic)
+        write(element)
+    return EncodeRepeatedField
+  else:
+    def EncodeField(write, value, deterministic):
+      write(tag)
+      local_EncodeVarint(write, local_len(value), deterministic)
+      return write(value)
+    return EncodeField
+
+
+def GroupEncoder(field_number, is_repeated, is_packed):
+  """Returns an encoder for a group field."""
+
+  start_tag = TagBytes(field_number, wire_format.WIRETYPE_START_GROUP)
+  end_tag = TagBytes(field_number, wire_format.WIRETYPE_END_GROUP)
+  assert not is_packed
+  if is_repeated:
+    def EncodeRepeatedField(write, value, deterministic):
+      for element in value:
+        write(start_tag)
+        element._InternalSerialize(write, deterministic)
+        write(end_tag)
+    return EncodeRepeatedField
+  else:
+    def EncodeField(write, value, deterministic):
+      write(start_tag)
+      value._InternalSerialize(write, deterministic)
+      return write(end_tag)
+    return EncodeField
+
+
+def MessageEncoder(field_number, is_repeated, is_packed):
+  """Returns an encoder for a message field."""
+
+  tag = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED)
+  local_EncodeVarint = _EncodeVarint
+  assert not is_packed
+  if is_repeated:
+    def EncodeRepeatedField(write, value, deterministic):
+      for element in value:
+        write(tag)
+        local_EncodeVarint(write, element.ByteSize(), deterministic)
+        element._InternalSerialize(write, deterministic)
+    return EncodeRepeatedField
+  else:
+    def EncodeField(write, value, deterministic):
+      write(tag)
+      local_EncodeVarint(write, value.ByteSize(), deterministic)
+      return value._InternalSerialize(write, deterministic)
+    return EncodeField
+
+
+# --------------------------------------------------------------------
+# As before, MessageSet is special.
+
+
+def MessageSetItemEncoder(field_number):
+  """Encoder for extensions of MessageSet.
+
+  The message set message looks like this:
+    message MessageSet {
+      repeated group Item = 1 {
+        required int32 type_id = 2;
+        required string message = 3;
+      }
+    }
+  """
+  start_bytes = b"".join([
+      TagBytes(1, wire_format.WIRETYPE_START_GROUP),
+      TagBytes(2, wire_format.WIRETYPE_VARINT),
+      _VarintBytes(field_number),
+      TagBytes(3, wire_format.WIRETYPE_LENGTH_DELIMITED)])
+  end_bytes = TagBytes(1, wire_format.WIRETYPE_END_GROUP)
+  local_EncodeVarint = _EncodeVarint
+
+  def EncodeField(write, value, deterministic):
+    write(start_bytes)
+    local_EncodeVarint(write, value.ByteSize(), deterministic)
+    value._InternalSerialize(write, deterministic)
+    return write(end_bytes)
+
+  return EncodeField
+
+
+# --------------------------------------------------------------------
+# As before, Map is special.
+
+
+def MapEncoder(field_descriptor):
+  """Encoder for extensions of MessageSet.
+
+  Maps always have a wire format like this:
+    message MapEntry {
+      key_type key = 1;
+      value_type value = 2;
+    }
+    repeated MapEntry map = N;
+  """
+  # Can't look at field_descriptor.message_type._concrete_class because it may
+  # not have been initialized yet.
+  message_type = field_descriptor.message_type
+  encode_message = MessageEncoder(field_descriptor.number, False, False)
+
+  def EncodeField(write, value, deterministic):
+    value_keys = sorted(value.keys()) if deterministic else value
+    for key in value_keys:
+      entry_msg = message_type._concrete_class(key=key, value=value[key])
+      encode_message(write, entry_msg, deterministic)
+
+  return EncodeField

.venv/lib/python3.11/site-packages/google/protobuf/internal/python_edition_defaults.py

@@ -0,0 +1,5 @@
+"""
+This file contains the serialized FeatureSetDefaults object corresponding to
+the Pure Python runtime.  This is used for feature resolution under Editions.
+"""
+_PROTOBUF_INTERNAL_PYTHON_EDITION_DEFAULTS = b"\n\023\030\204\007\"\000*\014\010\001\020\002\030\002 \003(\0010\002\n\023\030\347\007\"\000*\014\010\002\020\001\030\001 \002(\0010\001\n\023\030\350\007\"\014\010\001\020\001\030\001 \002(\0010\001*\000 \346\007(\350\007"

.venv/lib/python3.11/site-packages/google/protobuf/internal/testing_refleaks.py

@@ -0,0 +1,119 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+"""A subclass of unittest.TestCase which checks for reference leaks.
+
+To use:
+- Use testing_refleak.BaseTestCase instead of unittest.TestCase
+- Configure and compile Python with --with-pydebug
+
+If sys.gettotalrefcount() is not available (because Python was built without
+the Py_DEBUG option), then this module is a no-op and tests will run normally.
+"""
+
+import copyreg
+import gc
+import sys
+import unittest
+
+
+class LocalTestResult(unittest.TestResult):
+  """A TestResult which forwards events to a parent object, except for Skips."""
+
+  def __init__(self, parent_result):
+    unittest.TestResult.__init__(self)
+    self.parent_result = parent_result
+
+  def addError(self, test, error):
+    self.parent_result.addError(test, error)
+
+  def addFailure(self, test, error):
+    self.parent_result.addFailure(test, error)
+
+  def addSkip(self, test, reason):
+    pass
+
+
+class ReferenceLeakCheckerMixin(object):
+  """A mixin class for TestCase, which checks reference counts."""
+
+  NB_RUNS = 3
+
+  def run(self, result=None):
+    testMethod = getattr(self, self._testMethodName)
+    expecting_failure_method = getattr(testMethod, "__unittest_expecting_failure__", False)
+    expecting_failure_class = getattr(self, "__unittest_expecting_failure__", False)
+    if expecting_failure_class or expecting_failure_method:
+      return
+
+    # python_message.py registers all Message classes to some pickle global
+    # registry, which makes the classes immortal.
+    # We save a copy of this registry, and reset it before we could references.
+    self._saved_pickle_registry = copyreg.dispatch_table.copy()
+
+    # Run the test twice, to warm up the instance attributes.
+    super(ReferenceLeakCheckerMixin, self).run(result=result)
+    super(ReferenceLeakCheckerMixin, self).run(result=result)
+
+    oldrefcount = 0
+    local_result = LocalTestResult(result)
+    num_flakes = 0
+
+    refcount_deltas = []
+    while len(refcount_deltas) < self.NB_RUNS:
+      oldrefcount = self._getRefcounts()
+      super(ReferenceLeakCheckerMixin, self).run(result=local_result)
+      newrefcount = self._getRefcounts()
+      # If the GC was able to collect some objects after the call to run() that
+      # it could not collect before the call, then the counts won't match.
+      if newrefcount < oldrefcount and num_flakes < 2:
+        # This result is (probably) a flake -- garbage collectors aren't very
+        # predictable, but a lower ending refcount is the opposite of the
+        # failure we are testing for. If the result is repeatable, then we will
+        # eventually report it, but not after trying to eliminate it.
+        num_flakes += 1
+        continue
+      num_flakes = 0
+      refcount_deltas.append(newrefcount - oldrefcount)
+    print(refcount_deltas, self)
+
+    try:
+      self.assertEqual(refcount_deltas, [0] * self.NB_RUNS)
+    except Exception:  # pylint: disable=broad-except
+      result.addError(self, sys.exc_info())
+
+  def _getRefcounts(self):
+    copyreg.dispatch_table.clear()
+    copyreg.dispatch_table.update(self._saved_pickle_registry)
+    # It is sometimes necessary to gc.collect() multiple times, to ensure
+    # that all objects can be collected.
+    gc.collect()
+    gc.collect()
+    gc.collect()
+    return sys.gettotalrefcount()
+
+
+if hasattr(sys, 'gettotalrefcount'):
+
+  def TestCase(test_class):
+    new_bases = (ReferenceLeakCheckerMixin,) + test_class.__bases__
+    new_class = type(test_class)(
+        test_class.__name__, new_bases, dict(test_class.__dict__))
+    return new_class
+  SkipReferenceLeakChecker = unittest.skip
+
+else:
+  # When PyDEBUG is not enabled, run the tests normally.
+
+  def TestCase(test_class):
+    return test_class
+
+  def SkipReferenceLeakChecker(reason):
+    del reason  # Don't skip, so don't need a reason.
+    def Same(func):
+      return func
+    return Same

.venv/lib/python3.11/site-packages/google/protobuf/internal/well_known_types.py

@@ -0,0 +1,678 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2008 Google Inc.  All rights reserved.
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+"""Contains well known classes.
+
+This files defines well known classes which need extra maintenance including:
+  - Any
+  - Duration
+  - FieldMask
+  - Struct
+  - Timestamp
+"""
+
+__author__ = 'jieluo@google.com (Jie Luo)'
+
+import calendar
+import collections.abc
+import datetime
+import warnings
+from google.protobuf.internal import field_mask
+from typing import Union
+
+FieldMask = field_mask.FieldMask
+
+_TIMESTAMPFOMAT = '%Y-%m-%dT%H:%M:%S'
+_NANOS_PER_SECOND = 1000000000
+_NANOS_PER_MILLISECOND = 1000000
+_NANOS_PER_MICROSECOND = 1000
+_MILLIS_PER_SECOND = 1000
+_MICROS_PER_SECOND = 1000000
+_SECONDS_PER_DAY = 24 * 3600
+_DURATION_SECONDS_MAX = 315576000000
+_TIMESTAMP_SECONDS_MIN = -62135596800
+_TIMESTAMP_SECONDS_MAX = 253402300799
+
+_EPOCH_DATETIME_NAIVE = datetime.datetime(1970, 1, 1, tzinfo=None)
+_EPOCH_DATETIME_AWARE = _EPOCH_DATETIME_NAIVE.replace(
+    tzinfo=datetime.timezone.utc
+)
+
+
+class Any(object):
+  """Class for Any Message type."""
+
+  __slots__ = ()
+
+  def Pack(self, msg, type_url_prefix='type.googleapis.com/',
+           deterministic=None):
+    """Packs the specified message into current Any message."""
+    if len(type_url_prefix) < 1 or type_url_prefix[-1] != '/':
+      self.type_url = '%s/%s' % (type_url_prefix, msg.DESCRIPTOR.full_name)
+    else:
+      self.type_url = '%s%s' % (type_url_prefix, msg.DESCRIPTOR.full_name)
+    self.value = msg.SerializeToString(deterministic=deterministic)
+
+  def Unpack(self, msg):
+    """Unpacks the current Any message into specified message."""
+    descriptor = msg.DESCRIPTOR
+    if not self.Is(descriptor):
+      return False
+    msg.ParseFromString(self.value)
+    return True
+
+  def TypeName(self):
+    """Returns the protobuf type name of the inner message."""
+    # Only last part is to be used: b/25630112
+    return self.type_url.split('/')[-1]
+
+  def Is(self, descriptor):
+    """Checks if this Any represents the given protobuf type."""
+    return '/' in self.type_url and self.TypeName() == descriptor.full_name
+
+
+class Timestamp(object):
+  """Class for Timestamp message type."""
+
+  __slots__ = ()
+
+  def ToJsonString(self):
+    """Converts Timestamp to RFC 3339 date string format.
+
+    Returns:
+      A string converted from timestamp. The string is always Z-normalized
+      and uses 3, 6 or 9 fractional digits as required to represent the
+      exact time. Example of the return format: '1972-01-01T10:00:20.021Z'
+    """
+    _CheckTimestampValid(self.seconds, self.nanos)
+    nanos = self.nanos
+    seconds = self.seconds % _SECONDS_PER_DAY
+    days = (self.seconds - seconds) // _SECONDS_PER_DAY
+    dt = datetime.datetime(1970, 1, 1) + datetime.timedelta(days, seconds)
+
+    result = dt.isoformat()
+    if (nanos % 1e9) == 0:
+      # If there are 0 fractional digits, the fractional
+      # point '.' should be omitted when serializing.
+      return result + 'Z'
+    if (nanos % 1e6) == 0:
+      # Serialize 3 fractional digits.
+      return result + '.%03dZ' % (nanos / 1e6)
+    if (nanos % 1e3) == 0:
+      # Serialize 6 fractional digits.
+      return result + '.%06dZ' % (nanos / 1e3)
+    # Serialize 9 fractional digits.
+    return result + '.%09dZ' % nanos
+
+  def FromJsonString(self, value):
+    """Parse a RFC 3339 date string format to Timestamp.
+
+    Args:
+      value: A date string. Any fractional digits (or none) and any offset are
+          accepted as long as they fit into nano-seconds precision.
+          Example of accepted format: '1972-01-01T10:00:20.021-05:00'
+
+    Raises:
+      ValueError: On parsing problems.
+    """
+    if not isinstance(value, str):
+      raise ValueError('Timestamp JSON value not a string: {!r}'.format(value))
+    timezone_offset = value.find('Z')
+    if timezone_offset == -1:
+      timezone_offset = value.find('+')
+    if timezone_offset == -1:
+      timezone_offset = value.rfind('-')
+    if timezone_offset == -1:
+      raise ValueError(
+          'Failed to parse timestamp: missing valid timezone offset.')
+    time_value = value[0:timezone_offset]
+    # Parse datetime and nanos.
+    point_position = time_value.find('.')
+    if point_position == -1:
+      second_value = time_value
+      nano_value = ''
+    else:
+      second_value = time_value[:point_position]
+      nano_value = time_value[point_position + 1:]
+    if 't' in second_value:
+      raise ValueError(
+          'time data \'{0}\' does not match format \'%Y-%m-%dT%H:%M:%S\', '
+          'lowercase \'t\' is not accepted'.format(second_value))
+    date_object = datetime.datetime.strptime(second_value, _TIMESTAMPFOMAT)
+    td = date_object - datetime.datetime(1970, 1, 1)
+    seconds = td.seconds + td.days * _SECONDS_PER_DAY
+    if len(nano_value) > 9:
+      raise ValueError(
+          'Failed to parse Timestamp: nanos {0} more than '
+          '9 fractional digits.'.format(nano_value))
+    if nano_value:
+      nanos = round(float('0.' + nano_value) * 1e9)
+    else:
+      nanos = 0
+    # Parse timezone offsets.
+    if value[timezone_offset] == 'Z':
+      if len(value) != timezone_offset + 1:
+        raise ValueError('Failed to parse timestamp: invalid trailing'
+                         ' data {0}.'.format(value))
+    else:
+      timezone = value[timezone_offset:]
+      pos = timezone.find(':')
+      if pos == -1:
+        raise ValueError(
+            'Invalid timezone offset value: {0}.'.format(timezone))
+      if timezone[0] == '+':
+        seconds -= (int(timezone[1:pos])*60+int(timezone[pos+1:]))*60
+      else:
+        seconds += (int(timezone[1:pos])*60+int(timezone[pos+1:]))*60
+    # Set seconds and nanos
+    _CheckTimestampValid(seconds, nanos)
+    self.seconds = int(seconds)
+    self.nanos = int(nanos)
+
+  def GetCurrentTime(self):
+    """Get the current UTC into Timestamp."""
+    self.FromDatetime(datetime.datetime.utcnow())
+
+  def ToNanoseconds(self):
+    """Converts Timestamp to nanoseconds since epoch."""
+    _CheckTimestampValid(self.seconds, self.nanos)
+    return self.seconds * _NANOS_PER_SECOND + self.nanos
+
+  def ToMicroseconds(self):
+    """Converts Timestamp to microseconds since epoch."""
+    _CheckTimestampValid(self.seconds, self.nanos)
+    return (self.seconds * _MICROS_PER_SECOND +
+            self.nanos // _NANOS_PER_MICROSECOND)
+
+  def ToMilliseconds(self):
+    """Converts Timestamp to milliseconds since epoch."""
+    _CheckTimestampValid(self.seconds, self.nanos)
+    return (self.seconds * _MILLIS_PER_SECOND +
+            self.nanos // _NANOS_PER_MILLISECOND)
+
+  def ToSeconds(self):
+    """Converts Timestamp to seconds since epoch."""
+    _CheckTimestampValid(self.seconds, self.nanos)
+    return self.seconds
+
+  def FromNanoseconds(self, nanos):
+    """Converts nanoseconds since epoch to Timestamp."""
+    seconds = nanos // _NANOS_PER_SECOND
+    nanos = nanos % _NANOS_PER_SECOND
+    _CheckTimestampValid(seconds, nanos)
+    self.seconds = seconds
+    self.nanos = nanos
+
+  def FromMicroseconds(self, micros):
+    """Converts microseconds since epoch to Timestamp."""
+    seconds = micros // _MICROS_PER_SECOND
+    nanos = (micros % _MICROS_PER_SECOND) * _NANOS_PER_MICROSECOND
+    _CheckTimestampValid(seconds, nanos)
+    self.seconds = seconds
+    self.nanos = nanos
+
+  def FromMilliseconds(self, millis):
+    """Converts milliseconds since epoch to Timestamp."""
+    seconds = millis // _MILLIS_PER_SECOND
+    nanos = (millis % _MILLIS_PER_SECOND) * _NANOS_PER_MILLISECOND
+    _CheckTimestampValid(seconds, nanos)
+    self.seconds = seconds
+    self.nanos = nanos
+
+  def FromSeconds(self, seconds):
+    """Converts seconds since epoch to Timestamp."""
+    _CheckTimestampValid(seconds, 0)
+    self.seconds = seconds
+    self.nanos = 0
+
+  def ToDatetime(self, tzinfo=None):
+    """Converts Timestamp to a datetime.
+
+    Args:
+      tzinfo: A datetime.tzinfo subclass; defaults to None.
+
+    Returns:
+      If tzinfo is None, returns a timezone-naive UTC datetime (with no timezone
+      information, i.e. not aware that it's UTC).
+
+      Otherwise, returns a timezone-aware datetime in the input timezone.
+    """
+    # Using datetime.fromtimestamp for this would avoid constructing an extra
+    # timedelta object and possibly an extra datetime. Unfortunately, that has
+    # the disadvantage of not handling the full precision (on all platforms, see
+    # https://github.com/python/cpython/issues/109849) or full range (on some
+    # platforms, see https://github.com/python/cpython/issues/110042) of
+    # datetime.
+    _CheckTimestampValid(self.seconds, self.nanos)
+    delta = datetime.timedelta(
+        seconds=self.seconds,
+        microseconds=_RoundTowardZero(self.nanos, _NANOS_PER_MICROSECOND),
+    )
+    if tzinfo is None:
+      return _EPOCH_DATETIME_NAIVE + delta
+    else:
+      # Note the tz conversion has to come after the timedelta arithmetic.
+      return (_EPOCH_DATETIME_AWARE + delta).astimezone(tzinfo)
+
+  def FromDatetime(self, dt):
+    """Converts datetime to Timestamp.
+
+    Args:
+      dt: A datetime. If it's timezone-naive, it's assumed to be in UTC.
+    """
+    # Using this guide: http://wiki.python.org/moin/WorkingWithTime
+    # And this conversion guide: http://docs.python.org/library/time.html
+
+    # Turn the date parameter into a tuple (struct_time) that can then be
+    # manipulated into a long value of seconds.  During the conversion from
+    # struct_time to long, the source date in UTC, and so it follows that the
+    # correct transformation is calendar.timegm()
+    try:
+      seconds = calendar.timegm(dt.utctimetuple())
+      nanos = dt.microsecond * _NANOS_PER_MICROSECOND
+    except AttributeError as e:
+      raise AttributeError(
+          'Fail to convert to Timestamp. Expected a datetime like '
+          'object got {0} : {1}'.format(type(dt).__name__, e)
+      ) from e
+    _CheckTimestampValid(seconds, nanos)
+    self.seconds = seconds
+    self.nanos = nanos
+
+  def _internal_assign(self, dt):
+    self.FromDatetime(dt)
+
+  def __add__(self, value) -> datetime.datetime:
+    if isinstance(value, Duration):
+      return self.ToDatetime() + value.ToTimedelta()
+    return self.ToDatetime() + value
+
+  __radd__ = __add__
+
+  def __sub__(self, value) -> Union[datetime.datetime, datetime.timedelta]:
+    if isinstance(value, Timestamp):
+      return self.ToDatetime() - value.ToDatetime()
+    elif isinstance(value, Duration):
+      return self.ToDatetime() - value.ToTimedelta()
+    return self.ToDatetime() - value
+
+  def __rsub__(self, dt) -> datetime.timedelta:
+    return dt - self.ToDatetime()
+
+
+def _CheckTimestampValid(seconds, nanos):
+  if seconds < _TIMESTAMP_SECONDS_MIN or seconds > _TIMESTAMP_SECONDS_MAX:
+    raise ValueError(
+        'Timestamp is not valid: Seconds {0} must be in range '
+        '[-62135596800, 253402300799].'.format(seconds))
+  if nanos < 0 or nanos >= _NANOS_PER_SECOND:
+    raise ValueError(
+        'Timestamp is not valid: Nanos {} must be in a range '
+        '[0, 999999].'.format(nanos))
+
+
+class Duration(object):
+  """Class for Duration message type."""
+
+  __slots__ = ()
+
+  def ToJsonString(self):
+    """Converts Duration to string format.
+
+    Returns:
+      A string converted from self. The string format will contains
+      3, 6, or 9 fractional digits depending on the precision required to
+      represent the exact Duration value. For example: "1s", "1.010s",
+      "1.000000100s", "-3.100s"
+    """
+    _CheckDurationValid(self.seconds, self.nanos)
+    if self.seconds < 0 or self.nanos < 0:
+      result = '-'
+      seconds = - self.seconds + int((0 - self.nanos) // 1e9)
+      nanos = (0 - self.nanos) % 1e9
+    else:
+      result = ''
+      seconds = self.seconds + int(self.nanos // 1e9)
+      nanos = self.nanos % 1e9
+    result += '%d' % seconds
+    if (nanos % 1e9) == 0:
+      # If there are 0 fractional digits, the fractional
+      # point '.' should be omitted when serializing.
+      return result + 's'
+    if (nanos % 1e6) == 0:
+      # Serialize 3 fractional digits.
+      return result + '.%03ds' % (nanos / 1e6)
+    if (nanos % 1e3) == 0:
+      # Serialize 6 fractional digits.
+      return result + '.%06ds' % (nanos / 1e3)
+    # Serialize 9 fractional digits.
+    return result + '.%09ds' % nanos
+
+  def FromJsonString(self, value):
+    """Converts a string to Duration.
+
+    Args:
+      value: A string to be converted. The string must end with 's'. Any
+          fractional digits (or none) are accepted as long as they fit into
+          precision. For example: "1s", "1.01s", "1.0000001s", "-3.100s
+
+    Raises:
+      ValueError: On parsing problems.
+    """
+    if not isinstance(value, str):
+      raise ValueError('Duration JSON value not a string: {!r}'.format(value))
+    if len(value) < 1 or value[-1] != 's':
+      raise ValueError(
+          'Duration must end with letter "s": {0}.'.format(value))
+    try:
+      pos = value.find('.')
+      if pos == -1:
+        seconds = int(value[:-1])
+        nanos = 0
+      else:
+        seconds = int(value[:pos])
+        if value[0] == '-':
+          nanos = int(round(float('-0{0}'.format(value[pos: -1])) *1e9))
+        else:
+          nanos = int(round(float('0{0}'.format(value[pos: -1])) *1e9))
+      _CheckDurationValid(seconds, nanos)
+      self.seconds = seconds
+      self.nanos = nanos
+    except ValueError as e:
+      raise ValueError(
+          'Couldn\'t parse duration: {0} : {1}.'.format(value, e))
+
+  def ToNanoseconds(self):
+    """Converts a Duration to nanoseconds."""
+    return self.seconds * _NANOS_PER_SECOND + self.nanos
+
+  def ToMicroseconds(self):
+    """Converts a Duration to microseconds."""
+    micros = _RoundTowardZero(self.nanos, _NANOS_PER_MICROSECOND)
+    return self.seconds * _MICROS_PER_SECOND + micros
+
+  def ToMilliseconds(self):
+    """Converts a Duration to milliseconds."""
+    millis = _RoundTowardZero(self.nanos, _NANOS_PER_MILLISECOND)
+    return self.seconds * _MILLIS_PER_SECOND + millis
+
+  def ToSeconds(self):
+    """Converts a Duration to seconds."""
+    return self.seconds
+
+  def FromNanoseconds(self, nanos):
+    """Converts nanoseconds to Duration."""
+    self._NormalizeDuration(nanos // _NANOS_PER_SECOND,
+                            nanos % _NANOS_PER_SECOND)
+
+  def FromMicroseconds(self, micros):
+    """Converts microseconds to Duration."""
+    self._NormalizeDuration(
+        micros // _MICROS_PER_SECOND,
+        (micros % _MICROS_PER_SECOND) * _NANOS_PER_MICROSECOND)
+
+  def FromMilliseconds(self, millis):
+    """Converts milliseconds to Duration."""
+    self._NormalizeDuration(
+        millis // _MILLIS_PER_SECOND,
+        (millis % _MILLIS_PER_SECOND) * _NANOS_PER_MILLISECOND)
+
+  def FromSeconds(self, seconds):
+    """Converts seconds to Duration."""
+    self.seconds = seconds
+    self.nanos = 0
+
+  def ToTimedelta(self) -> datetime.timedelta:
+    """Converts Duration to timedelta."""
+    return datetime.timedelta(
+        seconds=self.seconds, microseconds=_RoundTowardZero(
+            self.nanos, _NANOS_PER_MICROSECOND))
+
+  def FromTimedelta(self, td):
+    """Converts timedelta to Duration."""
+    try:
+      self._NormalizeDuration(
+          td.seconds + td.days * _SECONDS_PER_DAY,
+          td.microseconds * _NANOS_PER_MICROSECOND,
+      )
+    except AttributeError as e:
+      raise AttributeError(
+          'Fail to convert to Duration. Expected a timedelta like '
+          'object got {0}: {1}'.format(type(td).__name__, e)
+      ) from e
+
+  def _internal_assign(self, td):
+    self.FromTimedelta(td)
+
+  def _NormalizeDuration(self, seconds, nanos):
+    """Set Duration by seconds and nanos."""
+    # Force nanos to be negative if the duration is negative.
+    if seconds < 0 and nanos > 0:
+      seconds += 1
+      nanos -= _NANOS_PER_SECOND
+    self.seconds = seconds
+    self.nanos = nanos
+
+  def __add__(self, value) -> Union[datetime.datetime, datetime.timedelta]:
+    if isinstance(value, Timestamp):
+      return self.ToTimedelta() + value.ToDatetime()
+    return self.ToTimedelta() + value
+
+  __radd__ = __add__
+
+  def __rsub__(self, dt) -> Union[datetime.datetime, datetime.timedelta]:
+    return dt - self.ToTimedelta()
+
+
+def _CheckDurationValid(seconds, nanos):
+  if seconds < -_DURATION_SECONDS_MAX or seconds > _DURATION_SECONDS_MAX:
+    raise ValueError(
+        'Duration is not valid: Seconds {0} must be in range '
+        '[-315576000000, 315576000000].'.format(seconds))
+  if nanos <= -_NANOS_PER_SECOND or nanos >= _NANOS_PER_SECOND:
+    raise ValueError(
+        'Duration is not valid: Nanos {0} must be in range '
+        '[-999999999, 999999999].'.format(nanos))
+  if (nanos < 0 and seconds > 0) or (nanos > 0 and seconds < 0):
+    raise ValueError(
+        'Duration is not valid: Sign mismatch.')
+
+
+def _RoundTowardZero(value, divider):
+  """Truncates the remainder part after division."""
+  # For some languages, the sign of the remainder is implementation
+  # dependent if any of the operands is negative. Here we enforce
+  # "rounded toward zero" semantics. For example, for (-5) / 2 an
+  # implementation may give -3 as the result with the remainder being
+  # 1. This function ensures we always return -2 (closer to zero).
+  result = value // divider
+  remainder = value % divider
+  if result < 0 and remainder > 0:
+    return result + 1
+  else:
+    return result
+
+
+def _SetStructValue(struct_value, value):
+  if value is None:
+    struct_value.null_value = 0
+  elif isinstance(value, bool):
+    # Note: this check must come before the number check because in Python
+    # True and False are also considered numbers.
+    struct_value.bool_value = value
+  elif isinstance(value, str):
+    struct_value.string_value = value
+  elif isinstance(value, (int, float)):
+    struct_value.number_value = value
+  elif isinstance(value, (dict, Struct)):
+    struct_value.struct_value.Clear()
+    struct_value.struct_value.update(value)
+  elif isinstance(value, (list, tuple, ListValue)):
+    struct_value.list_value.Clear()
+    struct_value.list_value.extend(value)
+  else:
+    raise ValueError('Unexpected type')
+
+
+def _GetStructValue(struct_value):
+  which = struct_value.WhichOneof('kind')
+  if which == 'struct_value':
+    return struct_value.struct_value
+  elif which == 'null_value':
+    return None
+  elif which == 'number_value':
+    return struct_value.number_value
+  elif which == 'string_value':
+    return struct_value.string_value
+  elif which == 'bool_value':
+    return struct_value.bool_value
+  elif which == 'list_value':
+    return struct_value.list_value
+  elif which is None:
+    raise ValueError('Value not set')
+
+
+class Struct(object):
+  """Class for Struct message type."""
+
+  __slots__ = ()
+
+  def __getitem__(self, key):
+    return _GetStructValue(self.fields[key])
+
+  def __setitem__(self, key, value):
+    _SetStructValue(self.fields[key], value)
+
+  def __delitem__(self, key):
+    del self.fields[key]
+
+  def __len__(self):
+    return len(self.fields)
+
+  def __iter__(self):
+    return iter(self.fields)
+
+  def _internal_assign(self, dictionary):
+    self.Clear()
+    self.update(dictionary)
+
+  def _internal_compare(self, other):
+    size = len(self)
+    if size != len(other):
+      return False
+    for key, value in self.items():
+      if key not in other:
+        return False
+      if isinstance(other[key], (dict, list)):
+        if not value._internal_compare(other[key]):
+          return False
+      elif value != other[key]:
+        return False
+    return True
+
+  def keys(self):  # pylint: disable=invalid-name
+    return self.fields.keys()
+
+  def values(self):  # pylint: disable=invalid-name
+    return [self[key] for key in self]
+
+  def items(self):  # pylint: disable=invalid-name
+    return [(key, self[key]) for key in self]
+
+  def get_or_create_list(self, key):
+    """Returns a list for this key, creating if it didn't exist already."""
+    if not self.fields[key].HasField('list_value'):
+      # Clear will mark list_value modified which will indeed create a list.
+      self.fields[key].list_value.Clear()
+    return self.fields[key].list_value
+
+  def get_or_create_struct(self, key):
+    """Returns a struct for this key, creating if it didn't exist already."""
+    if not self.fields[key].HasField('struct_value'):
+      # Clear will mark struct_value modified which will indeed create a struct.
+      self.fields[key].struct_value.Clear()
+    return self.fields[key].struct_value
+
+  def update(self, dictionary):  # pylint: disable=invalid-name
+    for key, value in dictionary.items():
+      _SetStructValue(self.fields[key], value)
+
+collections.abc.MutableMapping.register(Struct)
+
+
+class ListValue(object):
+  """Class for ListValue message type."""
+
+  __slots__ = ()
+
+  def __len__(self):
+    return len(self.values)
+
+  def append(self, value):
+    _SetStructValue(self.values.add(), value)
+
+  def extend(self, elem_seq):
+    for value in elem_seq:
+      self.append(value)
+
+  def __getitem__(self, index):
+    """Retrieves item by the specified index."""
+    return _GetStructValue(self.values.__getitem__(index))
+
+  def __setitem__(self, index, value):
+    _SetStructValue(self.values.__getitem__(index), value)
+
+  def __delitem__(self, key):
+    del self.values[key]
+
+  def _internal_assign(self, elem_seq):
+    self.Clear()
+    self.extend(elem_seq)
+
+  def _internal_compare(self, other):
+    size = len(self)
+    if size != len(other):
+      return False
+    for i in range(size):
+      if isinstance(other[i], (dict, list)):
+        if not self[i]._internal_compare(other[i]):
+          return False
+      elif self[i] != other[i]:
+        return False
+    return True
+
+  def items(self):
+    for i in range(len(self)):
+      yield self[i]
+
+  def add_struct(self):
+    """Appends and returns a struct value as the next value in the list."""
+    struct_value = self.values.add().struct_value
+    # Clear will mark struct_value modified which will indeed create a struct.
+    struct_value.Clear()
+    return struct_value
+
+  def add_list(self):
+    """Appends and returns a list value as the next value in the list."""
+    list_value = self.values.add().list_value
+    # Clear will mark list_value modified which will indeed create a list.
+    list_value.Clear()
+    return list_value
+
+collections.abc.MutableSequence.register(ListValue)
+
+
+# LINT.IfChange(wktbases)
+WKTBASES = {
+    'google.protobuf.Any': Any,
+    'google.protobuf.Duration': Duration,
+    'google.protobuf.FieldMask': FieldMask,
+    'google.protobuf.ListValue': ListValue,
+    'google.protobuf.Struct': Struct,
+    'google.protobuf.Timestamp': Timestamp,
+}
+# LINT.ThenChange(//depot/google.protobuf/compiler/python/pyi_generator.cc:wktbases)