google/generativeai/responder.py [71:269]: - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 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) strip_additional_properties(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 strip_additional_properties(schema): schema.pop("additionalProperties", None) properties = schema.get("properties", None) if properties is not None: for name, value in properties.items(): strip_additional_properties(value) items = schema.get("items", None) if items is not None: strip_additional_properties(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) - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - google/generativeai/types/content_types.py [343:541]: - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 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) strip_additional_properties(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 strip_additional_properties(schema): schema.pop("additionalProperties", None) properties = schema.get("properties", None) if properties is not None: for name, value in properties.items(): strip_additional_properties(value) items = schema.get("items", None) if items is not None: strip_additional_properties(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) - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -