Package Contents
		client models (package)

Classes
		gen_ai_hub.prompt_registry.client.PromptRegistryClient(abc.ABC) gen_ai_hub.prompt_registry.client.OrchestrationConfigClient gen_ai_hub.prompt_registry.client.PromptTemplateClient pydantic.main.BaseModel(builtins.object) gen_ai_hub.prompt_registry.models.orchestration_config.OrchestrationConfigDeleteResponse gen_ai_hub.prompt_registry.models.orchestration_config.OrchestrationConfigGetResponse gen_ai_hub.prompt_registry.models.orchestration_config.OrchestrationConfigListResponse gen_ai_hub.prompt_registry.models.orchestration_config.OrchestrationConfigPostRequest gen_ai_hub.prompt_registry.models.orchestration_config.OrchestrationConfigPostResponse gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplate gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateDeleteResponse gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateGetResponse gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateListResponse gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplatePostRequest gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplatePostResponse gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateSpec gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateSubstitutionRequest gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateSubstitutionResponse   class OrchestrationConfigClient(PromptRegistryClient)     OrchestrationConfigClient(proxy_client: Optional[gen_ai_hub.proxy.gen_ai_hub_proxy.client.GenAIHubProxyClient] = None)   Client for interacting with the Prompt Registry Orchestration Config API.   https://api.sap.com/api/PROMPT_REGISTRY_API/overview     Method resolution order: OrchestrationConfigClient PromptRegistryClient abc.ABC builtins.object Methods defined here: create_orchestration_config(self, name: str, version: str, scenario: str, spec: gen_ai_hub.orchestration_v2.models.config.OrchestrationConfig | dict) -> gen_ai_hub.prompt_registry.models.orchestration_config.OrchestrationConfigPostResponse Create an orchestration config.   :param name: the name of the orchestration config. :type name: str :param version: the version of the orchestration config. :type version: str :param scenario: the scenario name of the orchestration config. :type scenario: str :param spec: the specification of the orchestration config. :type spec: Union[dict, OrchestrationConfig]   :return: An OrchestrationConfigPostResponse object. :rtype: OrchestrationConfigPostResponse delete_orchestration_config_by_id(self, config_id: str) -> gen_ai_hub.prompt_registry.models.orchestration_config.OrchestrationConfigDeleteResponse Delete a specific version of the orchestration config by ID.   :param config_id: The ID of the orchestration config. :type config_id: str   :return: An OrchestrationConfigDeleteResponse object. :rtype: OrchestrationConfigDeleteResponse export_orchestration_config(self, config_id: str) -> bytes Export a design orchestration config  in a declarative compatible yaml file. Supports only single file export.   :param config_id: The id of the orchestration config to export. :type config_id: str :return: bytes: The content of the exported file :rtype: bytes get_orchestration_config_by_id(self, config_id: str, resolve_template_ref: bool = None) -> gen_ai_hub.prompt_registry.models.orchestration_config.OrchestrationConfigGetResponse Retrieve a specific version of the orchestration config by ID.   :param config_id: The ID of the orchestration config to retrieve. :type config_id: str :param resolve_template_ref: false(default), true :type resolve_template_ref: bool, optional   :return: An OrchestrationConfigGetResponse object. :rtype: OrchestrationConfigGetResponse get_orchestration_config_history(self, scenario: str, name: str, version: str, include_spec: bool = None, resolve_template_ref: bool = None) -> gen_ai_hub.prompt_registry.models.orchestration_config.OrchestrationConfigListResponse Retrieve the history of edits to the orchestration config.   :param scenario: The scenario name of the orchestration config. :type scenario: str :param name: The name of the orchestration config. :type name: str :param version: The version ID of the orchestration config. :type version: str :param include_spec: false(default), true :type include_spec: bool, optional :param resolve_template_ref: false(default), true :type resolve_template_ref: bool, optional   :return: An OrchestrationConfigListResponse object. :rtype: OrchestrationConfigListResponse get_orchestration_configs(self, scenario: str, name: str, version: str, retrieve: str = None, include_spec: bool = None, resolve_template_ref: bool = None) -> gen_ai_hub.prompt_registry.models.orchestration_config.OrchestrationConfigListResponse Retrieve the latest version of every orchestration config based on the filters.   :param scenario: the scenario name of the orchestration config. :type scenario: str :param name: the name of the orchestration config. :type name: str :param version: the version of the orchestration config. :type version: str :param retrieve: both(default), imperative, declarative :type retrieve: str, optional :param include_spec: false(default), true :type include_spec: bool, optional :param resolve_template_ref: false(default), true :type resolve_template_ref: bool, optional   :return: An OrchestrationConfigListResponse object. :rtype: OrchestrationConfigListResponse import_orchestration_config(self, file: bytes) -> gen_ai_hub.prompt_registry.models.orchestration_config.OrchestrationConfigPostResponse Import a runtime/declarative orchestration config into the design time environment.   :param file: binary file content :type file: bytes :return: A OrchestrationConfigPostResponse object. :rtype: OrchestrationConfigPostResponse Data and other attributes defined here: __abstractmethods__ = frozenset() __annotations__ = {} Methods inherited from PromptRegistryClient: __init__(self, proxy_client: Optional[gen_ai_hub.proxy.gen_ai_hub_proxy.client.GenAIHubProxyClient] = None) Initializes the PromptRegistryClient.   :param proxy_client: Optional proxy client to use for requests. :type proxy_client: Optional[GenAIHubProxyClient], optional Data descriptors inherited from PromptRegistryClient: __dict__ dictionary for instance variables (if defined) __weakref__ list of weak references to the object (if defined)   class OrchestrationConfigDeleteResponse(pydantic.main.BaseModel)     OrchestrationConfigDeleteResponse(*, message: str) -&gt; None   Response to a delete orchestration config request.   Args:     message: Response message.     Method resolution order: OrchestrationConfigDeleteResponse pydantic.main.BaseModel builtins.object Data descriptors defined here: __weakref__ list of weak references to the object (if defined) Data and other attributes defined here: __abstractmethods__ = frozenset() __annotations__ = {'message': <class 'str'>} __class_vars__ = set() __private_attributes__ = {} __pydantic_complete__ = True __pydantic_computed_fields__ = {} __pydantic_core_schema__ = {'cls': <class 'gen_ai_hub.prompt_registry.models.orchestration_config.OrchestrationConfigDeleteResponse'>, 'config': {'title': 'OrchestrationConfigDeleteResponse'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...ation_config.OrchestrationConfigDeleteResponse'>>]}, 'ref': 'gen_ai_hub.prompt_registry.models.orchestration_...OrchestrationConfigDeleteResponse:140540950968144', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'message': {'metadata': {}, 'schema': {'type': 'str'}, 'type': 'model-field'}}, 'model_name': 'OrchestrationConfigDeleteResponse', 'type': 'model-fields'}, 'type': 'model'} __pydantic_custom_init__ = False __pydantic_decorators__ = DecoratorInfos(validators={}, field_validators={...zers={}, model_validators={}, computed_fields={}) __pydantic_extra_info__ = None __pydantic_fields__ = {'message': FieldInfo(annotation=str, required=True)} __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'parameters': ()} __pydantic_parent_namespace__ = None __pydantic_post_init__ = None __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTrampoli...led_from_config: false, }, ), definitions=[]) __pydantic_setattr_handlers__ = {} __pydantic_validator__ = SchemaValidator(title="OrchestrationConfigDelete...e", }, ), definitions=[], cache_strings=True) __signature__ = <Signature (*, message: str) -> None> model_config = {} Methods inherited from pydantic.main.BaseModel: __copy__(self) -> 'Self' Returns a shallow copy of the model. __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self' Returns a deep copy of the model. __delattr__(self, item: 'str') -> 'Any' Implement delattr(self, name). __eq__(self, other: 'Any') -> 'bool' Return self==value. __getattr__(self, item: 'str') -> 'Any' __getstate__(self) -> 'dict[Any, Any]' __init__(self, /, **data: 'Any') -> 'None' Create a new model by parsing and validating input data from keyword arguments.   Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.   `self` is explicitly positional-only to allow `self` as a field name. __iter__(self) -> 'TupleGenerator' So `dict(model)` works. __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects. __replace__(self, **changes: 'Any') -> 'Self' # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block: __repr__(self) -> 'str' Return repr(self). __repr_args__(self) -> '_repr.ReprArgs' __repr_name__(self) -> 'str' Name of the instance's class, used in __repr__. __repr_recursion__(self, object: 'Any') -> 'str' Returns the string representation of a recursive object. __repr_str__(self, join_str: 'str') -> 'str' __rich_repr__(self) -> 'RichReprResult' Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects. __setattr__(self, name: 'str', value: 'Any') -> 'None' Implement setattr(self, name, value). __setstate__(self, state: 'dict[Any, Any]') -> 'None' __str__(self) -> 'str' Return str(self). copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self' Returns a copy of the model.   !!! warning "Deprecated"     This method is now deprecated; use `model_copy` instead.   If you need `include` or `exclude`, use:   ```python {test="skip" lint="skip"} data = self.model_dump(include=include, exclude=exclude, round_trip=True) data = {**data, **(update or {})} copied = self.model_validate(data) ```   Args:     include: Optional set or mapping specifying which fields to include in the copied model.     exclude: Optional set or mapping specifying which fields to exclude in the copied model.     update: Optional dictionary of field-value pairs to override field values in the copied model.     deep: If True, the values of fields that are Pydantic models will be deep-copied.   Returns:     A copy of the model with included, excluded and updated fields as specified. dict(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False) -> 'Dict[str, Any]' json(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str' model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self' !!! abstract "Usage Documentation"     [`model_copy`](../concepts/models.md#model-copy)   Returns a copy of the model.   !!! note     The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This     might have unexpected side effects if you store anything in it, on top of the model     fields (e.g. the value of [cached properties][functools.cached_property]).   Args:     update: Values to change/add in the new model. Note: the data is not validated         before creating the new model. You should trust this data.     deep: Set to `True` to make a deep copy of the model.   Returns:     New model instance. model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]' !!! abstract "Usage Documentation"     [`model_dump`](../concepts/serialization.md#python-mode)   Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.   Args:     mode: The mode in which `to_python` should run.         If mode is 'json', the output will only contain JSON serializable types.         If mode is 'python', the output may contain non-JSON-serializable Python objects.     include: A set of fields to include in the output.     exclude: A set of fields to exclude from the output.     context: Additional context to pass to the serializer.     by_alias: Whether to use the field's alias in the dictionary key if defined.     exclude_unset: Whether to exclude fields that have not been explicitly set.     exclude_defaults: Whether to exclude fields that are set to their default value.     exclude_none: Whether to exclude fields that have a value of `None`.     exclude_computed_fields: Whether to exclude computed fields.         While this can be useful for round-tripping, it is usually recommended to use the dedicated         `round_trip` parameter instead.     round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].     warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,         "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].     fallback: A function to call when an unknown value is encountered. If not provided,         a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.     serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.     polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.   Returns:     A dictionary representation of the model. model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str' !!! abstract "Usage Documentation"     [`model_dump_json`](../concepts/serialization.md#json-mode)   Generates a JSON representation of the model using Pydantic's `to_json` method.   Args:     indent: Indentation to use in the JSON output. If None is passed, the output will be compact.     ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.         If `False` (the default), these characters will be output as-is.     include: Field(s) to include in the JSON output.     exclude: Field(s) to exclude from the JSON output.     context: Additional context to pass to the serializer.     by_alias: Whether to serialize using field aliases.     exclude_unset: Whether to exclude fields that have not been explicitly set.     exclude_defaults: Whether to exclude fields that are set to their default value.     exclude_none: Whether to exclude fields that have a value of `None`.     exclude_computed_fields: Whether to exclude computed fields.         While this can be useful for round-tripping, it is usually recommended to use the dedicated         `round_trip` parameter instead.     round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].     warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,         "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].     fallback: A function to call when an unknown value is encountered. If not provided,         a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.     serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.     polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.   Returns:     A JSON string representation of the model. model_post_init(self, context: 'Any', /) -> 'None' Override this method to perform additional initialization after `__init__` and `model_construct`. This is useful if you want to do some validation that requires the entire model to be initialized. Class methods inherited from pydantic.main.BaseModel: __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef' from pydantic._internal._model_construction.ModelMetaclass __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema' from pydantic._internal._model_construction.ModelMetaclass __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue' from pydantic._internal._model_construction.ModelMetaclass Hook into generating the model's JSON schema.   Args:     core_schema: A `pydantic-core` CoreSchema.         You can ignore this argument and call the handler with a new CoreSchema,         wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),         or just call the handler with the original schema.     handler: Call into Pydantic's internal JSON schema generation.         This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema         generation fails.         Since this gets called by `BaseModel.model_json_schema` you can override the         `schema_generator` argument to that function to change JSON schema generation globally         for a type.   Returns:     A JSON schema, as a Python object. __pydantic_init_subclass__(**kwargs: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass` only after basic class initialization is complete. In particular, attributes like `model_fields` will be present when this is called, but forward annotations are not guaranteed to be resolved yet, meaning that creating an instance of the class may fail.   This is necessary because `__init_subclass__` will always be called by `type.__new__`, and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that `type.__new__` was called in such a manner that the class would already be sufficiently initialized.   This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely, any kwargs passed to the class definition that aren't used internally by Pydantic.   Args:     **kwargs: Any keyword arguments passed to the class definition that aren't used internally         by Pydantic.   Note:     You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]     instead, which is called once the class and its fields are fully initialized and ready for validation. __pydantic_on_complete__() -> 'None' from pydantic._internal._model_construction.ModelMetaclass This is called once the class and its fields are fully initialized and ready to be used.   This typically happens when the class is created (just before [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass), except when forward annotations are used that could not immediately be resolved. In that case, it will be called later, when the model is rebuilt automatically or explicitly using [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild]. construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass from_orm(obj: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Creates a new instance of the `Model` class with validated data.   Creates a new model setting `__dict__` and `__pydantic_fields_set__` from trusted or pre-validated data. Default values are respected, but no other validation is performed.   !!! note     `model_construct()` generally respects the `model_config.extra` setting on the provided model.     That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`     and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.     Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in     an error if extra values are passed, but they will be ignored.   Args:     _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,         this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.         Otherwise, the field names from the `values` argument will be used.     values: Trusted or pre-validated data dictionary.   Returns:     A new instance of the `Model` class with validated data. model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]' from pydantic._internal._model_construction.ModelMetaclass Generates a JSON schema for a model class.   Args:     by_alias: Whether to use attribute aliases or not.     ref_template: The reference template.     union_format: The format to use when combining schemas from unions together. Can be one of:           - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)         keyword to combine schemas (the default).         - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)         keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive         type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to         `any_of`.     schema_generator: To override the logic used to generate the JSON schema, as a subclass of         `GenerateJsonSchema` with your desired modifications     mode: The mode in which to generate the schema.   Returns:     The JSON schema for the given model class. model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str' from pydantic._internal._model_construction.ModelMetaclass Compute the class name for parametrizations of generic classes.   This method can be overridden to achieve a custom naming scheme for generic BaseModels.   Args:     params: Tuple of types of the class. Given a generic class         `Model` with 2 type variables and a concrete model `Model[str, int]`,         the value `(str, int)` would be passed to `params`.   Returns:     String representing the new class where `params` are passed to `cls` as type variables.   Raises:     TypeError: Raised when trying to generate concrete names for non-generic models. model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None' from pydantic._internal._model_construction.ModelMetaclass Try to rebuild the pydantic-core schema for the model.   This may be necessary when one of the annotations is a ForwardRef which could not be resolved during the initial attempt to build the schema, and automatic rebuilding fails.   Args:     force: Whether to force the rebuilding of the model schema, defaults to `False`.     raise_errors: Whether to raise errors, defaults to `True`.     _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.     _types_namespace: The types namespace, defaults to `None`.   Returns:     Returns `None` if the schema is already "complete" and rebuilding was not required.     If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`. model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Validate a pydantic model instance.   Args:     obj: The object to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     from_attributes: Whether to extract data from object attributes.     context: Additional context to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Raises:     ValidationError: If the object could not be validated.   Returns:     The validated model instance. model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass !!! abstract "Usage Documentation"     [JSON Parsing](../concepts/json.md#json-parsing)   Validate the given JSON data against the Pydantic model.   Args:     json_data: The JSON data to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     context: Extra variables to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Returns:     The validated Pydantic model.   Raises:     ValidationError: If `json_data` is not a JSON string or the object could not be validated. model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Validate the given object with string data against the Pydantic model.   Args:     obj: The object containing string data to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     context: Extra variables to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Returns:     The validated Pydantic model. parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass parse_obj(obj: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]' from pydantic._internal._model_construction.ModelMetaclass schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str' from pydantic._internal._model_construction.ModelMetaclass update_forward_refs(**localns: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass validate(value: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Readonly properties inherited from pydantic.main.BaseModel: __fields_set__ model_extra Get extra fields set during validation.   Returns:     A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`. model_fields_set Returns the set of fields that have been explicitly set on this model instance.   Returns:     A set of strings representing the fields that have been set,         i.e. that were not filled from defaults. Data descriptors inherited from pydantic.main.BaseModel: __dict__ dictionary for instance variables (if defined) __pydantic_extra__ __pydantic_fields_set__ __pydantic_private__ Data and other attributes inherited from pydantic.main.BaseModel: __hash__ = None __pydantic_root_model__ = False model_computed_fields = {} model_fields = {'message': FieldInfo(annotation=str, required=True)}   class OrchestrationConfigGetResponse(pydantic.main.BaseModel)     OrchestrationConfigGetResponse(*, id: Optional[str] = None, name: Optional[str] = None, version: Optional[str] = None, scenario: Optional[str] = None, creation_timestamp: Optional[str] = None, managed_by: Optional[str] = None, is_version_head: Optional[bool] = None, resource_group_id: Optional[str] = None, spec: Optional[gen_ai_hub.orchestration_v2.models.config.OrchestrationConfig] = None) -&gt; None   Response to a get orchestration config request.   Args:     id: UUID of the config.     name: Config name.     version: Config version.     scenario: Scenario name.     creation_timestamp: When the config was created.     managed_by: Who manages the config.     is_version_head: Whether this is the head version.     spec: The orchestration config specification (optional).     Method resolution order: OrchestrationConfigGetResponse pydantic.main.BaseModel builtins.object Methods defined here: model_dump(self, **kwargs) Dumps the model to a dictionary with default settings. Data descriptors defined here: __weakref__ list of weak references to the object (if defined) Data and other attributes defined here: __abstractmethods__ = frozenset() __annotations__ = {'creation_timestamp': typing.Optional[str], 'id': typing.Optional[str], 'is_version_head': typing.Optional[bool], 'managed_by': typing.Optional[str], 'name': typing.Optional[str], 'resource_group_id': typing.Optional[str], 'scenario': typing.Optional[str], 'spec': typing.Optional[gen_ai_hub.orchestration_v2.models.config.OrchestrationConfig], 'version': typing.Optional[str]} __class_vars__ = set() __private_attributes__ = {} __pydantic_complete__ = True __pydantic_computed_fields__ = {} __pydantic_core_schema__ = {'definitions': [{'cls': <class 'gen_ai_hub.orchestration_v2.models.config.ModuleConfig'>, 'config': {'extra_fields_behavior': 'forbid', 'title': 'ModuleConfig'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...ub.orchestration_v2.models.config.ModuleConfig'>>]}, 'ref': 'gen_ai_hub.orchestration_v2.models.config.ModuleConfig:140540952300112', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'filtering': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'grounding': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'masking': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'prompt_templating': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'translation': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}}, 'model_name': 'ModuleConfig', 'type': 'model-fields'}, 'type': 'model'}, {'cls': <class 'gen_ai_hub.orchestration_v2.models.multimodal_items.TextPart'>, 'config': {'extra_fields_behavior': 'forbid', 'title': 'TextPart'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...hestration_v2.models.multimodal_items.TextPart'>>]}, 'ref': 'gen_ai_hub.orchestration_v2.models.multimodal_items.TextPart:140540952612800', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'text': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'type_': {'metadata': {}, 'schema': {...}, 'serialization_alias': 'type', 'type': 'model-field', 'validation_alias': 'type'}}, 'model_name': 'TextPart', 'type': 'model-fields'}, 'type': 'model'}, {'cls': <class 'gen_ai_hub.orchestration_v2.models.multimodal_items.ImagePart'>, 'config': {'extra_fields_behavior': 'forbid', 'title': 'ImagePart'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...estration_v2.models.multimodal_items.ImagePart'>>]}, 'ref': 'gen_ai_hub.orchestration_v2.models.multimodal_items.ImagePart:140540952617824', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'image_url': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'type_': {'metadata': {}, 'schema': {...}, 'serialization_alias': 'type', 'type': 'model-field', 'validation_alias': 'type'}}, 'model_name': 'ImagePart', 'type': 'model-fields'}, 'type': 'model'}, {'cls': <class 'gen_ai_hub.orchestration_v2.models.data_masking.MaskingProviderConfig'>, 'config': {'extra_fields_behavior': 'forbid', 'title': 'MaskingProviderConfig'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...n_v2.models.data_masking.MaskingProviderConfig'>>]}, 'ref': 'gen_ai_hub.orchestration_v2.models.data_masking.MaskingProviderConfig:140540954149488', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'allowlist': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'entities': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'mask_grounding_input': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'method': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'type_': {'metadata': {}, 'schema': {...}, 'serialization_alias': 'type', 'type': 'model-field', 'validation_alias': 'type'}}, 'model_name': 'MaskingProviderConfig', 'type': 'model-fields'}, 'type': 'model'}, {'cls': <class 'gen_ai_hub.orchestration_v2.models.document_grounding.KeyValueListPair'>, 'config': {'extra_fields_behavior': 'forbid', 'title': 'KeyValueListPair'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche..._v2.models.document_grounding.KeyValueListPair'>>]}, 'ref': 'gen_ai_hub.orchestration_v2.models.document_grounding.KeyValueListPair:140540952511168', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'key': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'value': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}}, 'model_name': 'KeyValueListPair', 'type': 'model-fields'}, 'type': 'model'}, {'cls': <class 'gen_ai_hub.orchestration_v2.models.translation.SAPDocumentTranslation'>, 'config': {'extra_fields_behavior': 'forbid', 'title': 'SAPDocumentTranslation'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...n_v2.models.translation.SAPDocumentTranslation'>>]}, 'ref': 'gen_ai_hub.orchestration_v2.models.translation.SAPDocumentTranslation:140540952286992', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'config': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'type_': {'metadata': {}, 'schema': {...}, 'serialization_alias': 'type', 'type': 'model-field', 'validation_alias': 'type'}}, 'model_name': 'SAPDocumentTranslation', 'type': 'model-fields'}, 'type': 'model'}], 'schema': {'cls': <class 'gen_ai_hub.prompt_registry.models.orchestration_config.OrchestrationConfigGetResponse'>, 'config': {'title': 'OrchestrationConfigGetResponse'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...stration_config.OrchestrationConfigGetResponse'>>]}, 'ref': 'gen_ai_hub.prompt_registry.models.orchestration_...ig.OrchestrationConfigGetResponse:140540950962096', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'creation_timestamp': {'metadata': {}, 'schema': {'default': None, 'schema': {...}, 'type': 'default'}, 'type': 'model-field'}, 'id': {'metadata': {}, 'schema': {'default': None, 'schema': {...}, 'type': 'default'}, 'type': 'model-field'}, 'is_version_head': {'metadata': {}, 'schema': {'default': None, 'schema': {...}, 'type': 'default'}, 'type': 'model-field'}, 'managed_by': {'metadata': {}, 'schema': {'default': None, 'schema': {...}, 'type': 'default'}, 'type': 'model-field'}, 'name': {'metadata': {}, 'schema': {'default': None, 'schema': {...}, 'type': 'default'}, 'type': 'model-field'}, 'resource_group_id': {'metadata': {}, 'schema': {'default': None, 'schema': {...}, 'type': 'default'}, 'type': 'model-field'}, 'scenario': {'metadata': {}, 'schema': {'default': None, 'schema': {...}, 'type': 'default'}, 'type': 'model-field'}, 'spec': {'metadata': {}, 'schema': {'default': None, 'schema': {...}, 'type': 'default'}, 'type': 'model-field'}, 'version': {'metadata': {}, 'schema': {'default': None, 'schema': {...}, 'type': 'default'}, 'type': 'model-field'}}, 'model_name': 'OrchestrationConfigGetResponse', 'type': 'model-fields'}, 'type': 'model'}, 'type': 'definitions'} __pydantic_custom_init__ = False __pydantic_decorators__ = DecoratorInfos(validators={}, field_validators={...zers={}, model_validators={}, computed_fields={}) __pydantic_extra_info__ = None __pydantic_fields__ = {'creation_timestamp': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'id': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'is_version_head': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'managed_by': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'resource_group_id': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'scenario': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'spec': FieldInfo(annotation=Union[OrchestrationConfig, NoneType], required=False, default=None), 'version': FieldInfo(annotation=Union[str, NoneType], required=False, default=None)} __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'parameters': ()} __pydantic_parent_namespace__ = None __pydantic_post_init__ = None __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTrampoli...7fd23d95bf40) }), enabled_from_config: false })]) __pydantic_setattr_handlers__ = {} __pydantic_validator__ = SchemaValidator(title="OrchestrationConfigGetRes...ator: Py(0x7fd23d95beb0) })], cache_strings=True) __signature__ = <Signature (*, id: Optional[str] = None, name: O...dels.config.OrchestrationConfig] = None) -> None> model_config = {} Methods inherited from pydantic.main.BaseModel: __copy__(self) -> 'Self' Returns a shallow copy of the model. __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self' Returns a deep copy of the model. __delattr__(self, item: 'str') -> 'Any' Implement delattr(self, name). __eq__(self, other: 'Any') -> 'bool' Return self==value. __getattr__(self, item: 'str') -> 'Any' __getstate__(self) -> 'dict[Any, Any]' __init__(self, /, **data: 'Any') -> 'None' Create a new model by parsing and validating input data from keyword arguments.   Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.   `self` is explicitly positional-only to allow `self` as a field name. __iter__(self) -> 'TupleGenerator' So `dict(model)` works. __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects. __replace__(self, **changes: 'Any') -> 'Self' # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block: __repr__(self) -> 'str' Return repr(self). __repr_args__(self) -> '_repr.ReprArgs' __repr_name__(self) -> 'str' Name of the instance's class, used in __repr__. __repr_recursion__(self, object: 'Any') -> 'str' Returns the string representation of a recursive object. __repr_str__(self, join_str: 'str') -> 'str' __rich_repr__(self) -> 'RichReprResult' Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects. __setattr__(self, name: 'str', value: 'Any') -> 'None' Implement setattr(self, name, value). __setstate__(self, state: 'dict[Any, Any]') -> 'None' __str__(self) -> 'str' Return str(self). copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self' Returns a copy of the model.   !!! warning "Deprecated"     This method is now deprecated; use `model_copy` instead.   If you need `include` or `exclude`, use:   ```python {test="skip" lint="skip"} data = self.model_dump(include=include, exclude=exclude, round_trip=True) data = {**data, **(update or {})} copied = self.model_validate(data) ```   Args:     include: Optional set or mapping specifying which fields to include in the copied model.     exclude: Optional set or mapping specifying which fields to exclude in the copied model.     update: Optional dictionary of field-value pairs to override field values in the copied model.     deep: If True, the values of fields that are Pydantic models will be deep-copied.   Returns:     A copy of the model with included, excluded and updated fields as specified. dict(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False) -> 'Dict[str, Any]' json(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str' model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self' !!! abstract "Usage Documentation"     [`model_copy`](../concepts/models.md#model-copy)   Returns a copy of the model.   !!! note     The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This     might have unexpected side effects if you store anything in it, on top of the model     fields (e.g. the value of [cached properties][functools.cached_property]).   Args:     update: Values to change/add in the new model. Note: the data is not validated         before creating the new model. You should trust this data.     deep: Set to `True` to make a deep copy of the model.   Returns:     New model instance. model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str' !!! abstract "Usage Documentation"     [`model_dump_json`](../concepts/serialization.md#json-mode)   Generates a JSON representation of the model using Pydantic's `to_json` method.   Args:     indent: Indentation to use in the JSON output. If None is passed, the output will be compact.     ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.         If `False` (the default), these characters will be output as-is.     include: Field(s) to include in the JSON output.     exclude: Field(s) to exclude from the JSON output.     context: Additional context to pass to the serializer.     by_alias: Whether to serialize using field aliases.     exclude_unset: Whether to exclude fields that have not been explicitly set.     exclude_defaults: Whether to exclude fields that are set to their default value.     exclude_none: Whether to exclude fields that have a value of `None`.     exclude_computed_fields: Whether to exclude computed fields.         While this can be useful for round-tripping, it is usually recommended to use the dedicated         `round_trip` parameter instead.     round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].     warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,         "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].     fallback: A function to call when an unknown value is encountered. If not provided,         a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.     serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.     polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.   Returns:     A JSON string representation of the model. model_post_init(self, context: 'Any', /) -> 'None' Override this method to perform additional initialization after `__init__` and `model_construct`. This is useful if you want to do some validation that requires the entire model to be initialized. Class methods inherited from pydantic.main.BaseModel: __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef' from pydantic._internal._model_construction.ModelMetaclass __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema' from pydantic._internal._model_construction.ModelMetaclass __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue' from pydantic._internal._model_construction.ModelMetaclass Hook into generating the model's JSON schema.   Args:     core_schema: A `pydantic-core` CoreSchema.         You can ignore this argument and call the handler with a new CoreSchema,         wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),         or just call the handler with the original schema.     handler: Call into Pydantic's internal JSON schema generation.         This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema         generation fails.         Since this gets called by `BaseModel.model_json_schema` you can override the         `schema_generator` argument to that function to change JSON schema generation globally         for a type.   Returns:     A JSON schema, as a Python object. __pydantic_init_subclass__(**kwargs: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass` only after basic class initialization is complete. In particular, attributes like `model_fields` will be present when this is called, but forward annotations are not guaranteed to be resolved yet, meaning that creating an instance of the class may fail.   This is necessary because `__init_subclass__` will always be called by `type.__new__`, and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that `type.__new__` was called in such a manner that the class would already be sufficiently initialized.   This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely, any kwargs passed to the class definition that aren't used internally by Pydantic.   Args:     **kwargs: Any keyword arguments passed to the class definition that aren't used internally         by Pydantic.   Note:     You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]     instead, which is called once the class and its fields are fully initialized and ready for validation. __pydantic_on_complete__() -> 'None' from pydantic._internal._model_construction.ModelMetaclass This is called once the class and its fields are fully initialized and ready to be used.   This typically happens when the class is created (just before [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass), except when forward annotations are used that could not immediately be resolved. In that case, it will be called later, when the model is rebuilt automatically or explicitly using [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild]. construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass from_orm(obj: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Creates a new instance of the `Model` class with validated data.   Creates a new model setting `__dict__` and `__pydantic_fields_set__` from trusted or pre-validated data. Default values are respected, but no other validation is performed.   !!! note     `model_construct()` generally respects the `model_config.extra` setting on the provided model.     That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`     and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.     Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in     an error if extra values are passed, but they will be ignored.   Args:     _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,         this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.         Otherwise, the field names from the `values` argument will be used.     values: Trusted or pre-validated data dictionary.   Returns:     A new instance of the `Model` class with validated data. model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]' from pydantic._internal._model_construction.ModelMetaclass Generates a JSON schema for a model class.   Args:     by_alias: Whether to use attribute aliases or not.     ref_template: The reference template.     union_format: The format to use when combining schemas from unions together. Can be one of:           - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)         keyword to combine schemas (the default).         - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)         keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive         type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to         `any_of`.     schema_generator: To override the logic used to generate the JSON schema, as a subclass of         `GenerateJsonSchema` with your desired modifications     mode: The mode in which to generate the schema.   Returns:     The JSON schema for the given model class. model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str' from pydantic._internal._model_construction.ModelMetaclass Compute the class name for parametrizations of generic classes.   This method can be overridden to achieve a custom naming scheme for generic BaseModels.   Args:     params: Tuple of types of the class. Given a generic class         `Model` with 2 type variables and a concrete model `Model[str, int]`,         the value `(str, int)` would be passed to `params`.   Returns:     String representing the new class where `params` are passed to `cls` as type variables.   Raises:     TypeError: Raised when trying to generate concrete names for non-generic models. model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None' from pydantic._internal._model_construction.ModelMetaclass Try to rebuild the pydantic-core schema for the model.   This may be necessary when one of the annotations is a ForwardRef which could not be resolved during the initial attempt to build the schema, and automatic rebuilding fails.   Args:     force: Whether to force the rebuilding of the model schema, defaults to `False`.     raise_errors: Whether to raise errors, defaults to `True`.     _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.     _types_namespace: The types namespace, defaults to `None`.   Returns:     Returns `None` if the schema is already "complete" and rebuilding was not required.     If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`. model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Validate a pydantic model instance.   Args:     obj: The object to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     from_attributes: Whether to extract data from object attributes.     context: Additional context to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Raises:     ValidationError: If the object could not be validated.   Returns:     The validated model instance. model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass !!! abstract "Usage Documentation"     [JSON Parsing](../concepts/json.md#json-parsing)   Validate the given JSON data against the Pydantic model.   Args:     json_data: The JSON data to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     context: Extra variables to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Returns:     The validated Pydantic model.   Raises:     ValidationError: If `json_data` is not a JSON string or the object could not be validated. model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Validate the given object with string data against the Pydantic model.   Args:     obj: The object containing string data to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     context: Extra variables to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Returns:     The validated Pydantic model. parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass parse_obj(obj: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]' from pydantic._internal._model_construction.ModelMetaclass schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str' from pydantic._internal._model_construction.ModelMetaclass update_forward_refs(**localns: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass validate(value: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Readonly properties inherited from pydantic.main.BaseModel: __fields_set__ model_extra Get extra fields set during validation.   Returns:     A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`. model_fields_set Returns the set of fields that have been explicitly set on this model instance.   Returns:     A set of strings representing the fields that have been set,         i.e. that were not filled from defaults. Data descriptors inherited from pydantic.main.BaseModel: __dict__ dictionary for instance variables (if defined) __pydantic_extra__ __pydantic_fields_set__ __pydantic_private__ Data and other attributes inherited from pydantic.main.BaseModel: __hash__ = None __pydantic_root_model__ = False model_computed_fields = {} model_fields = {'creation_timestamp': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'id': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'is_version_head': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'managed_by': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'resource_group_id': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'scenario': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'spec': FieldInfo(annotation=Union[OrchestrationConfig, NoneType], required=False, default=None), 'version': FieldInfo(annotation=Union[str, NoneType], required=False, default=None)}   class OrchestrationConfigListResponse(pydantic.main.BaseModel)     OrchestrationConfigListResponse(*, count: int, resources: List[gen_ai_hub.prompt_registry.models.orchestration_config.OrchestrationConfigGetResponse]) -&gt; None   Response to list orchestration configs request.   Args:     count: Number of configs returned.     resources: List of OrchestrationConfigGetResponse objects.     Method resolution order: OrchestrationConfigListResponse pydantic.main.BaseModel builtins.object Methods defined here: model_dump(self, **kwargs) Dumps the model to a dictionary with default settings. Data descriptors defined here: __weakref__ list of weak references to the object (if defined) Data and other attributes defined here: __abstractmethods__ = frozenset() __annotations__ = {'count': <class 'int'>, 'resources': typing.List[gen_ai_hub.prompt_registry.models.orchestration_config.OrchestrationConfigGetResponse]} __class_vars__ = set() __private_attributes__ = {} __pydantic_complete__ = True __pydantic_computed_fields__ = {} __pydantic_core_schema__ = {'definitions': [{'cls': <class 'gen_ai_hub.orchestration_v2.models.config.ModuleConfig'>, 'config': {'extra_fields_behavior': 'forbid', 'title': 'ModuleConfig'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...ub.orchestration_v2.models.config.ModuleConfig'>>]}, 'ref': 'gen_ai_hub.orchestration_v2.models.config.ModuleConfig:140540952300112', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'filtering': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'grounding': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'masking': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'prompt_templating': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'translation': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}}, 'model_name': 'ModuleConfig', 'type': 'model-fields'}, 'type': 'model'}, {'cls': <class 'gen_ai_hub.orchestration_v2.models.multimodal_items.TextPart'>, 'config': {'extra_fields_behavior': 'forbid', 'title': 'TextPart'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...hestration_v2.models.multimodal_items.TextPart'>>]}, 'ref': 'gen_ai_hub.orchestration_v2.models.multimodal_items.TextPart:140540952612800', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'text': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'type_': {'metadata': {}, 'schema': {...}, 'serialization_alias': 'type', 'type': 'model-field', 'validation_alias': 'type'}}, 'model_name': 'TextPart', 'type': 'model-fields'}, 'type': 'model'}, {'cls': <class 'gen_ai_hub.orchestration_v2.models.multimodal_items.ImagePart'>, 'config': {'extra_fields_behavior': 'forbid', 'title': 'ImagePart'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...estration_v2.models.multimodal_items.ImagePart'>>]}, 'ref': 'gen_ai_hub.orchestration_v2.models.multimodal_items.ImagePart:140540952617824', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'image_url': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'type_': {'metadata': {}, 'schema': {...}, 'serialization_alias': 'type', 'type': 'model-field', 'validation_alias': 'type'}}, 'model_name': 'ImagePart', 'type': 'model-fields'}, 'type': 'model'}, {'cls': <class 'gen_ai_hub.orchestration_v2.models.data_masking.MaskingProviderConfig'>, 'config': {'extra_fields_behavior': 'forbid', 'title': 'MaskingProviderConfig'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...n_v2.models.data_masking.MaskingProviderConfig'>>]}, 'ref': 'gen_ai_hub.orchestration_v2.models.data_masking.MaskingProviderConfig:140540954149488', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'allowlist': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'entities': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'mask_grounding_input': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'method': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'type_': {'metadata': {}, 'schema': {...}, 'serialization_alias': 'type', 'type': 'model-field', 'validation_alias': 'type'}}, 'model_name': 'MaskingProviderConfig', 'type': 'model-fields'}, 'type': 'model'}, {'cls': <class 'gen_ai_hub.orchestration_v2.models.document_grounding.KeyValueListPair'>, 'config': {'extra_fields_behavior': 'forbid', 'title': 'KeyValueListPair'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche..._v2.models.document_grounding.KeyValueListPair'>>]}, 'ref': 'gen_ai_hub.orchestration_v2.models.document_grounding.KeyValueListPair:140540952511168', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'key': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'value': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}}, 'model_name': 'KeyValueListPair', 'type': 'model-fields'}, 'type': 'model'}, {'cls': <class 'gen_ai_hub.orchestration_v2.models.translation.SAPDocumentTranslation'>, 'config': {'extra_fields_behavior': 'forbid', 'title': 'SAPDocumentTranslation'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...n_v2.models.translation.SAPDocumentTranslation'>>]}, 'ref': 'gen_ai_hub.orchestration_v2.models.translation.SAPDocumentTranslation:140540952286992', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'config': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'type_': {'metadata': {}, 'schema': {...}, 'serialization_alias': 'type', 'type': 'model-field', 'validation_alias': 'type'}}, 'model_name': 'SAPDocumentTranslation', 'type': 'model-fields'}, 'type': 'model'}], 'schema': {'cls': <class 'gen_ai_hub.prompt_registry.models.orchestration_config.OrchestrationConfigListResponse'>, 'config': {'title': 'OrchestrationConfigListResponse'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...tration_config.OrchestrationConfigListResponse'>>]}, 'ref': 'gen_ai_hub.prompt_registry.models.orchestration_...g.OrchestrationConfigListResponse:140540950963088', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'count': {'metadata': {}, 'schema': {'type': 'int'}, 'type': 'model-field'}, 'resources': {'metadata': {}, 'schema': {'items_schema': {...}, 'type': 'list'}, 'type': 'model-field'}}, 'model_name': 'OrchestrationConfigListResponse', 'type': 'model-fields'}, 'type': 'model'}, 'type': 'definitions'} __pydantic_custom_init__ = False __pydantic_decorators__ = DecoratorInfos(validators={}, field_validators={...zers={}, model_validators={}, computed_fields={}) __pydantic_extra_info__ = None __pydantic_fields__ = {'count': FieldInfo(annotation=int, required=True), 'resources': FieldInfo(annotation=List[OrchestrationConfigGetResponse], required=True)} __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'parameters': ()} __pydantic_parent_namespace__ = None __pydantic_post_init__ = None __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTrampoli...7fd23d95a3b0) }), enabled_from_config: false })]) __pydantic_setattr_handlers__ = {} __pydantic_validator__ = SchemaValidator(title="OrchestrationConfigListRe...ator: Py(0x7fd23dd2e200) })], cache_strings=True) __signature__ = <Signature (*, count: int, resources: List[gen_a..._config.OrchestrationConfigGetResponse]) -> None> model_config = {} Methods inherited from pydantic.main.BaseModel: __copy__(self) -> 'Self' Returns a shallow copy of the model. __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self' Returns a deep copy of the model. __delattr__(self, item: 'str') -> 'Any' Implement delattr(self, name). __eq__(self, other: 'Any') -> 'bool' Return self==value. __getattr__(self, item: 'str') -> 'Any' __getstate__(self) -> 'dict[Any, Any]' __init__(self, /, **data: 'Any') -> 'None' Create a new model by parsing and validating input data from keyword arguments.   Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.   `self` is explicitly positional-only to allow `self` as a field name. __iter__(self) -> 'TupleGenerator' So `dict(model)` works. __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects. __replace__(self, **changes: 'Any') -> 'Self' # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block: __repr__(self) -> 'str' Return repr(self). __repr_args__(self) -> '_repr.ReprArgs' __repr_name__(self) -> 'str' Name of the instance's class, used in __repr__. __repr_recursion__(self, object: 'Any') -> 'str' Returns the string representation of a recursive object. __repr_str__(self, join_str: 'str') -> 'str' __rich_repr__(self) -> 'RichReprResult' Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects. __setattr__(self, name: 'str', value: 'Any') -> 'None' Implement setattr(self, name, value). __setstate__(self, state: 'dict[Any, Any]') -> 'None' __str__(self) -> 'str' Return str(self). copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self' Returns a copy of the model.   !!! warning "Deprecated"     This method is now deprecated; use `model_copy` instead.   If you need `include` or `exclude`, use:   ```python {test="skip" lint="skip"} data = self.model_dump(include=include, exclude=exclude, round_trip=True) data = {**data, **(update or {})} copied = self.model_validate(data) ```   Args:     include: Optional set or mapping specifying which fields to include in the copied model.     exclude: Optional set or mapping specifying which fields to exclude in the copied model.     update: Optional dictionary of field-value pairs to override field values in the copied model.     deep: If True, the values of fields that are Pydantic models will be deep-copied.   Returns:     A copy of the model with included, excluded and updated fields as specified. dict(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False) -> 'Dict[str, Any]' json(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str' model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self' !!! abstract "Usage Documentation"     [`model_copy`](../concepts/models.md#model-copy)   Returns a copy of the model.   !!! note     The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This     might have unexpected side effects if you store anything in it, on top of the model     fields (e.g. the value of [cached properties][functools.cached_property]).   Args:     update: Values to change/add in the new model. Note: the data is not validated         before creating the new model. You should trust this data.     deep: Set to `True` to make a deep copy of the model.   Returns:     New model instance. model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str' !!! abstract "Usage Documentation"     [`model_dump_json`](../concepts/serialization.md#json-mode)   Generates a JSON representation of the model using Pydantic's `to_json` method.   Args:     indent: Indentation to use in the JSON output. If None is passed, the output will be compact.     ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.         If `False` (the default), these characters will be output as-is.     include: Field(s) to include in the JSON output.     exclude: Field(s) to exclude from the JSON output.     context: Additional context to pass to the serializer.     by_alias: Whether to serialize using field aliases.     exclude_unset: Whether to exclude fields that have not been explicitly set.     exclude_defaults: Whether to exclude fields that are set to their default value.     exclude_none: Whether to exclude fields that have a value of `None`.     exclude_computed_fields: Whether to exclude computed fields.         While this can be useful for round-tripping, it is usually recommended to use the dedicated         `round_trip` parameter instead.     round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].     warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,         "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].     fallback: A function to call when an unknown value is encountered. If not provided,         a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.     serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.     polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.   Returns:     A JSON string representation of the model. model_post_init(self, context: 'Any', /) -> 'None' Override this method to perform additional initialization after `__init__` and `model_construct`. This is useful if you want to do some validation that requires the entire model to be initialized. Class methods inherited from pydantic.main.BaseModel: __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef' from pydantic._internal._model_construction.ModelMetaclass __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema' from pydantic._internal._model_construction.ModelMetaclass __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue' from pydantic._internal._model_construction.ModelMetaclass Hook into generating the model's JSON schema.   Args:     core_schema: A `pydantic-core` CoreSchema.         You can ignore this argument and call the handler with a new CoreSchema,         wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),         or just call the handler with the original schema.     handler: Call into Pydantic's internal JSON schema generation.         This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema         generation fails.         Since this gets called by `BaseModel.model_json_schema` you can override the         `schema_generator` argument to that function to change JSON schema generation globally         for a type.   Returns:     A JSON schema, as a Python object. __pydantic_init_subclass__(**kwargs: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass` only after basic class initialization is complete. In particular, attributes like `model_fields` will be present when this is called, but forward annotations are not guaranteed to be resolved yet, meaning that creating an instance of the class may fail.   This is necessary because `__init_subclass__` will always be called by `type.__new__`, and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that `type.__new__` was called in such a manner that the class would already be sufficiently initialized.   This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely, any kwargs passed to the class definition that aren't used internally by Pydantic.   Args:     **kwargs: Any keyword arguments passed to the class definition that aren't used internally         by Pydantic.   Note:     You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]     instead, which is called once the class and its fields are fully initialized and ready for validation. __pydantic_on_complete__() -> 'None' from pydantic._internal._model_construction.ModelMetaclass This is called once the class and its fields are fully initialized and ready to be used.   This typically happens when the class is created (just before [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass), except when forward annotations are used that could not immediately be resolved. In that case, it will be called later, when the model is rebuilt automatically or explicitly using [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild]. construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass from_orm(obj: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Creates a new instance of the `Model` class with validated data.   Creates a new model setting `__dict__` and `__pydantic_fields_set__` from trusted or pre-validated data. Default values are respected, but no other validation is performed.   !!! note     `model_construct()` generally respects the `model_config.extra` setting on the provided model.     That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`     and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.     Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in     an error if extra values are passed, but they will be ignored.   Args:     _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,         this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.         Otherwise, the field names from the `values` argument will be used.     values: Trusted or pre-validated data dictionary.   Returns:     A new instance of the `Model` class with validated data. model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]' from pydantic._internal._model_construction.ModelMetaclass Generates a JSON schema for a model class.   Args:     by_alias: Whether to use attribute aliases or not.     ref_template: The reference template.     union_format: The format to use when combining schemas from unions together. Can be one of:           - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)         keyword to combine schemas (the default).         - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)         keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive         type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to         `any_of`.     schema_generator: To override the logic used to generate the JSON schema, as a subclass of         `GenerateJsonSchema` with your desired modifications     mode: The mode in which to generate the schema.   Returns:     The JSON schema for the given model class. model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str' from pydantic._internal._model_construction.ModelMetaclass Compute the class name for parametrizations of generic classes.   This method can be overridden to achieve a custom naming scheme for generic BaseModels.   Args:     params: Tuple of types of the class. Given a generic class         `Model` with 2 type variables and a concrete model `Model[str, int]`,         the value `(str, int)` would be passed to `params`.   Returns:     String representing the new class where `params` are passed to `cls` as type variables.   Raises:     TypeError: Raised when trying to generate concrete names for non-generic models. model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None' from pydantic._internal._model_construction.ModelMetaclass Try to rebuild the pydantic-core schema for the model.   This may be necessary when one of the annotations is a ForwardRef which could not be resolved during the initial attempt to build the schema, and automatic rebuilding fails.   Args:     force: Whether to force the rebuilding of the model schema, defaults to `False`.     raise_errors: Whether to raise errors, defaults to `True`.     _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.     _types_namespace: The types namespace, defaults to `None`.   Returns:     Returns `None` if the schema is already "complete" and rebuilding was not required.     If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`. model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Validate a pydantic model instance.   Args:     obj: The object to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     from_attributes: Whether to extract data from object attributes.     context: Additional context to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Raises:     ValidationError: If the object could not be validated.   Returns:     The validated model instance. model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass !!! abstract "Usage Documentation"     [JSON Parsing](../concepts/json.md#json-parsing)   Validate the given JSON data against the Pydantic model.   Args:     json_data: The JSON data to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     context: Extra variables to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Returns:     The validated Pydantic model.   Raises:     ValidationError: If `json_data` is not a JSON string or the object could not be validated. model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Validate the given object with string data against the Pydantic model.   Args:     obj: The object containing string data to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     context: Extra variables to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Returns:     The validated Pydantic model. parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass parse_obj(obj: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]' from pydantic._internal._model_construction.ModelMetaclass schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str' from pydantic._internal._model_construction.ModelMetaclass update_forward_refs(**localns: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass validate(value: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Readonly properties inherited from pydantic.main.BaseModel: __fields_set__ model_extra Get extra fields set during validation.   Returns:     A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`. model_fields_set Returns the set of fields that have been explicitly set on this model instance.   Returns:     A set of strings representing the fields that have been set,         i.e. that were not filled from defaults. Data descriptors inherited from pydantic.main.BaseModel: __dict__ dictionary for instance variables (if defined) __pydantic_extra__ __pydantic_fields_set__ __pydantic_private__ Data and other attributes inherited from pydantic.main.BaseModel: __hash__ = None __pydantic_root_model__ = False model_computed_fields = {} model_fields = {'count': FieldInfo(annotation=int, required=True), 'resources': FieldInfo(annotation=List[OrchestrationConfigGetResponse], required=True)}   class OrchestrationConfigPostRequest(pydantic.main.BaseModel)     OrchestrationConfigPostRequest(*, name: typing.Annotated[str, MaxLen(max_length=120)], version: typing.Annotated[str, MaxLen(max_length=10)], scenario: typing.Annotated[str, MaxLen(max_length=120)], spec: gen_ai_hub.orchestration_v2.models.config.OrchestrationConfig) -&gt; None   Request to create an orchestration config.   Args:     name: The name of the orchestration config.     version: The version of the orchestration config.     scenario: The scenario of the orchestration config.     spec: The orchestration config specification.     Method resolution order: OrchestrationConfigPostRequest pydantic.main.BaseModel builtins.object Methods defined here: model_dump(self, **kwargs) Dumps the model to a dictionary with default settings. Data descriptors defined here: __weakref__ list of weak references to the object (if defined) Data and other attributes defined here: __abstractmethods__ = frozenset() __annotations__ = {'name': <class 'str'>, 'scenario': <class 'str'>, 'spec': <class 'gen_ai_hub.orchestration_v2.models.config.OrchestrationConfig'>, 'version': <class 'str'>} __class_vars__ = set() __private_attributes__ = {} __pydantic_complete__ = True __pydantic_computed_fields__ = {} __pydantic_core_schema__ = {'definitions': [{'cls': <class 'gen_ai_hub.orchestration_v2.models.config.ModuleConfig'>, 'config': {'extra_fields_behavior': 'forbid', 'title': 'ModuleConfig'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...ub.orchestration_v2.models.config.ModuleConfig'>>]}, 'ref': 'gen_ai_hub.orchestration_v2.models.config.ModuleConfig:140540952300112', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'filtering': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'grounding': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'masking': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'prompt_templating': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'translation': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}}, 'model_name': 'ModuleConfig', 'type': 'model-fields'}, 'type': 'model'}, {'cls': <class 'gen_ai_hub.orchestration_v2.models.multimodal_items.TextPart'>, 'config': {'extra_fields_behavior': 'forbid', 'title': 'TextPart'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...hestration_v2.models.multimodal_items.TextPart'>>]}, 'ref': 'gen_ai_hub.orchestration_v2.models.multimodal_items.TextPart:140540952612800', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'text': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'type_': {'metadata': {}, 'schema': {...}, 'serialization_alias': 'type', 'type': 'model-field', 'validation_alias': 'type'}}, 'model_name': 'TextPart', 'type': 'model-fields'}, 'type': 'model'}, {'cls': <class 'gen_ai_hub.orchestration_v2.models.multimodal_items.ImagePart'>, 'config': {'extra_fields_behavior': 'forbid', 'title': 'ImagePart'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...estration_v2.models.multimodal_items.ImagePart'>>]}, 'ref': 'gen_ai_hub.orchestration_v2.models.multimodal_items.ImagePart:140540952617824', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'image_url': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'type_': {'metadata': {}, 'schema': {...}, 'serialization_alias': 'type', 'type': 'model-field', 'validation_alias': 'type'}}, 'model_name': 'ImagePart', 'type': 'model-fields'}, 'type': 'model'}, {'cls': <class 'gen_ai_hub.orchestration_v2.models.data_masking.MaskingProviderConfig'>, 'config': {'extra_fields_behavior': 'forbid', 'title': 'MaskingProviderConfig'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...n_v2.models.data_masking.MaskingProviderConfig'>>]}, 'ref': 'gen_ai_hub.orchestration_v2.models.data_masking.MaskingProviderConfig:140540954149488', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'allowlist': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'entities': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'mask_grounding_input': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'method': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'type_': {'metadata': {}, 'schema': {...}, 'serialization_alias': 'type', 'type': 'model-field', 'validation_alias': 'type'}}, 'model_name': 'MaskingProviderConfig', 'type': 'model-fields'}, 'type': 'model'}, {'cls': <class 'gen_ai_hub.orchestration_v2.models.document_grounding.KeyValueListPair'>, 'config': {'extra_fields_behavior': 'forbid', 'title': 'KeyValueListPair'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche..._v2.models.document_grounding.KeyValueListPair'>>]}, 'ref': 'gen_ai_hub.orchestration_v2.models.document_grounding.KeyValueListPair:140540952511168', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'key': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'value': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}}, 'model_name': 'KeyValueListPair', 'type': 'model-fields'}, 'type': 'model'}, {'cls': <class 'gen_ai_hub.orchestration_v2.models.translation.SAPDocumentTranslation'>, 'config': {'extra_fields_behavior': 'forbid', 'title': 'SAPDocumentTranslation'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...n_v2.models.translation.SAPDocumentTranslation'>>]}, 'ref': 'gen_ai_hub.orchestration_v2.models.translation.SAPDocumentTranslation:140540952286992', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'config': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'type_': {'metadata': {}, 'schema': {...}, 'serialization_alias': 'type', 'type': 'model-field', 'validation_alias': 'type'}}, 'model_name': 'SAPDocumentTranslation', 'type': 'model-fields'}, 'type': 'model'}], 'schema': {'cls': <class 'gen_ai_hub.prompt_registry.models.orchestration_config.OrchestrationConfigPostRequest'>, 'config': {'title': 'OrchestrationConfigPostRequest'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...stration_config.OrchestrationConfigPostRequest'>>]}, 'ref': 'gen_ai_hub.prompt_registry.models.orchestration_...ig.OrchestrationConfigPostRequest:140540950960064', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'name': {'metadata': {}, 'schema': {'max_length': 120, 'type': 'str'}, 'type': 'model-field'}, 'scenario': {'metadata': {}, 'schema': {'max_length': 120, 'type': 'str'}, 'type': 'model-field'}, 'spec': {'metadata': {}, 'schema': {'cls': <class 'gen_ai_hub.orchestration_v2.models.config.OrchestrationConfig'>, 'config': {...}, 'custom_init': False, 'metadata': {...}, 'ref': 'gen_ai_hub.orchestration_v2.models.config.OrchestrationConfig:140540951717936', 'root_model': False, 'schema': {...}, 'type': 'model'}, 'type': 'model-field'}, 'version': {'metadata': {}, 'schema': {'max_length': 10, 'type': 'str'}, 'type': 'model-field'}}, 'model_name': 'OrchestrationConfigPostRequest', 'type': 'model-fields'}, 'type': 'model'}, 'type': 'definitions'} __pydantic_custom_init__ = False __pydantic_decorators__ = DecoratorInfos(validators={}, field_validators={...zers={}, model_validators={}, computed_fields={}) __pydantic_extra_info__ = None __pydantic_fields__ = {'name': FieldInfo(annotation=str, required=True, metadata=[MaxLen(max_length=120)]), 'scenario': FieldInfo(annotation=str, required=True, metadata=[MaxLen(max_length=120)]), 'spec': FieldInfo(annotation=OrchestrationConfig, required=True), 'version': FieldInfo(annotation=str, required=True, metadata=[MaxLen(max_length=10)])} __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'parameters': ()} __pydantic_parent_namespace__ = None __pydantic_post_init__ = None __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTrampoli...7fd23d95aa70) }), enabled_from_config: false })]) __pydantic_setattr_handlers__ = {} __pydantic_validator__ = SchemaValidator(title="OrchestrationConfigPostRe...ator: Py(0x7fd23d9a0160) })], cache_strings=True) __signature__ = <Signature (*, name: typing.Annotated[str, MaxLe...on_v2.models.config.OrchestrationConfig) -> None> model_config = {} Methods inherited from pydantic.main.BaseModel: __copy__(self) -> 'Self' Returns a shallow copy of the model. __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self' Returns a deep copy of the model. __delattr__(self, item: 'str') -> 'Any' Implement delattr(self, name). __eq__(self, other: 'Any') -> 'bool' Return self==value. __getattr__(self, item: 'str') -> 'Any' __getstate__(self) -> 'dict[Any, Any]' __init__(self, /, **data: 'Any') -> 'None' Create a new model by parsing and validating input data from keyword arguments.   Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.   `self` is explicitly positional-only to allow `self` as a field name. __iter__(self) -> 'TupleGenerator' So `dict(model)` works. __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects. __replace__(self, **changes: 'Any') -> 'Self' # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block: __repr__(self) -> 'str' Return repr(self). __repr_args__(self) -> '_repr.ReprArgs' __repr_name__(self) -> 'str' Name of the instance's class, used in __repr__. __repr_recursion__(self, object: 'Any') -> 'str' Returns the string representation of a recursive object. __repr_str__(self, join_str: 'str') -> 'str' __rich_repr__(self) -> 'RichReprResult' Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects. __setattr__(self, name: 'str', value: 'Any') -> 'None' Implement setattr(self, name, value). __setstate__(self, state: 'dict[Any, Any]') -> 'None' __str__(self) -> 'str' Return str(self). copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self' Returns a copy of the model.   !!! warning "Deprecated"     This method is now deprecated; use `model_copy` instead.   If you need `include` or `exclude`, use:   ```python {test="skip" lint="skip"} data = self.model_dump(include=include, exclude=exclude, round_trip=True) data = {**data, **(update or {})} copied = self.model_validate(data) ```   Args:     include: Optional set or mapping specifying which fields to include in the copied model.     exclude: Optional set or mapping specifying which fields to exclude in the copied model.     update: Optional dictionary of field-value pairs to override field values in the copied model.     deep: If True, the values of fields that are Pydantic models will be deep-copied.   Returns:     A copy of the model with included, excluded and updated fields as specified. dict(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False) -> 'Dict[str, Any]' json(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str' model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self' !!! abstract "Usage Documentation"     [`model_copy`](../concepts/models.md#model-copy)   Returns a copy of the model.   !!! note     The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This     might have unexpected side effects if you store anything in it, on top of the model     fields (e.g. the value of [cached properties][functools.cached_property]).   Args:     update: Values to change/add in the new model. Note: the data is not validated         before creating the new model. You should trust this data.     deep: Set to `True` to make a deep copy of the model.   Returns:     New model instance. model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str' !!! abstract "Usage Documentation"     [`model_dump_json`](../concepts/serialization.md#json-mode)   Generates a JSON representation of the model using Pydantic's `to_json` method.   Args:     indent: Indentation to use in the JSON output. If None is passed, the output will be compact.     ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.         If `False` (the default), these characters will be output as-is.     include: Field(s) to include in the JSON output.     exclude: Field(s) to exclude from the JSON output.     context: Additional context to pass to the serializer.     by_alias: Whether to serialize using field aliases.     exclude_unset: Whether to exclude fields that have not been explicitly set.     exclude_defaults: Whether to exclude fields that are set to their default value.     exclude_none: Whether to exclude fields that have a value of `None`.     exclude_computed_fields: Whether to exclude computed fields.         While this can be useful for round-tripping, it is usually recommended to use the dedicated         `round_trip` parameter instead.     round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].     warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,         "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].     fallback: A function to call when an unknown value is encountered. If not provided,         a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.     serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.     polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.   Returns:     A JSON string representation of the model. model_post_init(self, context: 'Any', /) -> 'None' Override this method to perform additional initialization after `__init__` and `model_construct`. This is useful if you want to do some validation that requires the entire model to be initialized. Class methods inherited from pydantic.main.BaseModel: __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef' from pydantic._internal._model_construction.ModelMetaclass __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema' from pydantic._internal._model_construction.ModelMetaclass __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue' from pydantic._internal._model_construction.ModelMetaclass Hook into generating the model's JSON schema.   Args:     core_schema: A `pydantic-core` CoreSchema.         You can ignore this argument and call the handler with a new CoreSchema,         wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),         or just call the handler with the original schema.     handler: Call into Pydantic's internal JSON schema generation.         This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema         generation fails.         Since this gets called by `BaseModel.model_json_schema` you can override the         `schema_generator` argument to that function to change JSON schema generation globally         for a type.   Returns:     A JSON schema, as a Python object. __pydantic_init_subclass__(**kwargs: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass` only after basic class initialization is complete. In particular, attributes like `model_fields` will be present when this is called, but forward annotations are not guaranteed to be resolved yet, meaning that creating an instance of the class may fail.   This is necessary because `__init_subclass__` will always be called by `type.__new__`, and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that `type.__new__` was called in such a manner that the class would already be sufficiently initialized.   This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely, any kwargs passed to the class definition that aren't used internally by Pydantic.   Args:     **kwargs: Any keyword arguments passed to the class definition that aren't used internally         by Pydantic.   Note:     You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]     instead, which is called once the class and its fields are fully initialized and ready for validation. __pydantic_on_complete__() -> 'None' from pydantic._internal._model_construction.ModelMetaclass This is called once the class and its fields are fully initialized and ready to be used.   This typically happens when the class is created (just before [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass), except when forward annotations are used that could not immediately be resolved. In that case, it will be called later, when the model is rebuilt automatically or explicitly using [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild]. construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass from_orm(obj: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Creates a new instance of the `Model` class with validated data.   Creates a new model setting `__dict__` and `__pydantic_fields_set__` from trusted or pre-validated data. Default values are respected, but no other validation is performed.   !!! note     `model_construct()` generally respects the `model_config.extra` setting on the provided model.     That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`     and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.     Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in     an error if extra values are passed, but they will be ignored.   Args:     _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,         this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.         Otherwise, the field names from the `values` argument will be used.     values: Trusted or pre-validated data dictionary.   Returns:     A new instance of the `Model` class with validated data. model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]' from pydantic._internal._model_construction.ModelMetaclass Generates a JSON schema for a model class.   Args:     by_alias: Whether to use attribute aliases or not.     ref_template: The reference template.     union_format: The format to use when combining schemas from unions together. Can be one of:           - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)         keyword to combine schemas (the default).         - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)         keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive         type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to         `any_of`.     schema_generator: To override the logic used to generate the JSON schema, as a subclass of         `GenerateJsonSchema` with your desired modifications     mode: The mode in which to generate the schema.   Returns:     The JSON schema for the given model class. model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str' from pydantic._internal._model_construction.ModelMetaclass Compute the class name for parametrizations of generic classes.   This method can be overridden to achieve a custom naming scheme for generic BaseModels.   Args:     params: Tuple of types of the class. Given a generic class         `Model` with 2 type variables and a concrete model `Model[str, int]`,         the value `(str, int)` would be passed to `params`.   Returns:     String representing the new class where `params` are passed to `cls` as type variables.   Raises:     TypeError: Raised when trying to generate concrete names for non-generic models. model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None' from pydantic._internal._model_construction.ModelMetaclass Try to rebuild the pydantic-core schema for the model.   This may be necessary when one of the annotations is a ForwardRef which could not be resolved during the initial attempt to build the schema, and automatic rebuilding fails.   Args:     force: Whether to force the rebuilding of the model schema, defaults to `False`.     raise_errors: Whether to raise errors, defaults to `True`.     _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.     _types_namespace: The types namespace, defaults to `None`.   Returns:     Returns `None` if the schema is already "complete" and rebuilding was not required.     If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`. model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Validate a pydantic model instance.   Args:     obj: The object to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     from_attributes: Whether to extract data from object attributes.     context: Additional context to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Raises:     ValidationError: If the object could not be validated.   Returns:     The validated model instance. model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass !!! abstract "Usage Documentation"     [JSON Parsing](../concepts/json.md#json-parsing)   Validate the given JSON data against the Pydantic model.   Args:     json_data: The JSON data to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     context: Extra variables to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Returns:     The validated Pydantic model.   Raises:     ValidationError: If `json_data` is not a JSON string or the object could not be validated. model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Validate the given object with string data against the Pydantic model.   Args:     obj: The object containing string data to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     context: Extra variables to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Returns:     The validated Pydantic model. parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass parse_obj(obj: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]' from pydantic._internal._model_construction.ModelMetaclass schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str' from pydantic._internal._model_construction.ModelMetaclass update_forward_refs(**localns: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass validate(value: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Readonly properties inherited from pydantic.main.BaseModel: __fields_set__ model_extra Get extra fields set during validation.   Returns:     A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`. model_fields_set Returns the set of fields that have been explicitly set on this model instance.   Returns:     A set of strings representing the fields that have been set,         i.e. that were not filled from defaults. Data descriptors inherited from pydantic.main.BaseModel: __dict__ dictionary for instance variables (if defined) __pydantic_extra__ __pydantic_fields_set__ __pydantic_private__ Data and other attributes inherited from pydantic.main.BaseModel: __hash__ = None __pydantic_root_model__ = False model_computed_fields = {} model_fields = {'name': FieldInfo(annotation=str, required=True, metadata=[MaxLen(max_length=120)]), 'scenario': FieldInfo(annotation=str, required=True, metadata=[MaxLen(max_length=120)]), 'spec': FieldInfo(annotation=OrchestrationConfig, required=True), 'version': FieldInfo(annotation=str, required=True, metadata=[MaxLen(max_length=10)])}   class OrchestrationConfigPostResponse(pydantic.main.BaseModel)     OrchestrationConfigPostResponse(*, message: str, id: str, scenario: str, name: str, version: str) -&gt; None   Response to the orchestration config post request.   Args:     message: Response message.     id: UUID of the created/updated config.     scenario: The scenario name.     name: The config name.     version: The config version.     Method resolution order: OrchestrationConfigPostResponse pydantic.main.BaseModel builtins.object Data descriptors defined here: __weakref__ list of weak references to the object (if defined) Data and other attributes defined here: __abstractmethods__ = frozenset() __annotations__ = {'id': <class 'str'>, 'message': <class 'str'>, 'name': <class 'str'>, 'scenario': <class 'str'>, 'version': <class 'str'>} __class_vars__ = set() __private_attributes__ = {} __pydantic_complete__ = True __pydantic_computed_fields__ = {} __pydantic_core_schema__ = {'cls': <class 'gen_ai_hub.prompt_registry.models.orchestration_config.OrchestrationConfigPostResponse'>, 'config': {'title': 'OrchestrationConfigPostResponse'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...tration_config.OrchestrationConfigPostResponse'>>]}, 'ref': 'gen_ai_hub.prompt_registry.models.orchestration_...g.OrchestrationConfigPostResponse:140540950959104', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'id': {'metadata': {}, 'schema': {'type': 'str'}, 'type': 'model-field'}, 'message': {'metadata': {}, 'schema': {'type': 'str'}, 'type': 'model-field'}, 'name': {'metadata': {}, 'schema': {'type': 'str'}, 'type': 'model-field'}, 'scenario': {'metadata': {}, 'schema': {'type': 'str'}, 'type': 'model-field'}, 'version': {'metadata': {}, 'schema': {'type': 'str'}, 'type': 'model-field'}}, 'model_name': 'OrchestrationConfigPostResponse', 'type': 'model-fields'}, 'type': 'model'} __pydantic_custom_init__ = False __pydantic_decorators__ = DecoratorInfos(validators={}, field_validators={...zers={}, model_validators={}, computed_fields={}) __pydantic_extra_info__ = None __pydantic_fields__ = {'id': FieldInfo(annotation=str, required=True), 'message': FieldInfo(annotation=str, required=True), 'name': FieldInfo(annotation=str, required=True), 'scenario': FieldInfo(annotation=str, required=True), 'version': FieldInfo(annotation=str, required=True)} __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'parameters': ()} __pydantic_parent_namespace__ = None __pydantic_post_init__ = None __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTrampoli...led_from_config: false, }, ), definitions=[]) __pydantic_setattr_handlers__ = {} __pydantic_validator__ = SchemaValidator(title="OrchestrationConfigPostRe...e", }, ), definitions=[], cache_strings=True) __signature__ = <Signature (*, message: str, id: str, scenario: str, name: str, version: str) -> None> model_config = {} Methods inherited from pydantic.main.BaseModel: __copy__(self) -> 'Self' Returns a shallow copy of the model. __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self' Returns a deep copy of the model. __delattr__(self, item: 'str') -> 'Any' Implement delattr(self, name). __eq__(self, other: 'Any') -> 'bool' Return self==value. __getattr__(self, item: 'str') -> 'Any' __getstate__(self) -> 'dict[Any, Any]' __init__(self, /, **data: 'Any') -> 'None' Create a new model by parsing and validating input data from keyword arguments.   Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.   `self` is explicitly positional-only to allow `self` as a field name. __iter__(self) -> 'TupleGenerator' So `dict(model)` works. __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects. __replace__(self, **changes: 'Any') -> 'Self' # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block: __repr__(self) -> 'str' Return repr(self). __repr_args__(self) -> '_repr.ReprArgs' __repr_name__(self) -> 'str' Name of the instance's class, used in __repr__. __repr_recursion__(self, object: 'Any') -> 'str' Returns the string representation of a recursive object. __repr_str__(self, join_str: 'str') -> 'str' __rich_repr__(self) -> 'RichReprResult' Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects. __setattr__(self, name: 'str', value: 'Any') -> 'None' Implement setattr(self, name, value). __setstate__(self, state: 'dict[Any, Any]') -> 'None' __str__(self) -> 'str' Return str(self). copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self' Returns a copy of the model.   !!! warning "Deprecated"     This method is now deprecated; use `model_copy` instead.   If you need `include` or `exclude`, use:   ```python {test="skip" lint="skip"} data = self.model_dump(include=include, exclude=exclude, round_trip=True) data = {**data, **(update or {})} copied = self.model_validate(data) ```   Args:     include: Optional set or mapping specifying which fields to include in the copied model.     exclude: Optional set or mapping specifying which fields to exclude in the copied model.     update: Optional dictionary of field-value pairs to override field values in the copied model.     deep: If True, the values of fields that are Pydantic models will be deep-copied.   Returns:     A copy of the model with included, excluded and updated fields as specified. dict(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False) -> 'Dict[str, Any]' json(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str' model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self' !!! abstract "Usage Documentation"     [`model_copy`](../concepts/models.md#model-copy)   Returns a copy of the model.   !!! note     The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This     might have unexpected side effects if you store anything in it, on top of the model     fields (e.g. the value of [cached properties][functools.cached_property]).   Args:     update: Values to change/add in the new model. Note: the data is not validated         before creating the new model. You should trust this data.     deep: Set to `True` to make a deep copy of the model.   Returns:     New model instance. model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]' !!! abstract "Usage Documentation"     [`model_dump`](../concepts/serialization.md#python-mode)   Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.   Args:     mode: The mode in which `to_python` should run.         If mode is 'json', the output will only contain JSON serializable types.         If mode is 'python', the output may contain non-JSON-serializable Python objects.     include: A set of fields to include in the output.     exclude: A set of fields to exclude from the output.     context: Additional context to pass to the serializer.     by_alias: Whether to use the field's alias in the dictionary key if defined.     exclude_unset: Whether to exclude fields that have not been explicitly set.     exclude_defaults: Whether to exclude fields that are set to their default value.     exclude_none: Whether to exclude fields that have a value of `None`.     exclude_computed_fields: Whether to exclude computed fields.         While this can be useful for round-tripping, it is usually recommended to use the dedicated         `round_trip` parameter instead.     round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].     warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,         "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].     fallback: A function to call when an unknown value is encountered. If not provided,         a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.     serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.     polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.   Returns:     A dictionary representation of the model. model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str' !!! abstract "Usage Documentation"     [`model_dump_json`](../concepts/serialization.md#json-mode)   Generates a JSON representation of the model using Pydantic's `to_json` method.   Args:     indent: Indentation to use in the JSON output. If None is passed, the output will be compact.     ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.         If `False` (the default), these characters will be output as-is.     include: Field(s) to include in the JSON output.     exclude: Field(s) to exclude from the JSON output.     context: Additional context to pass to the serializer.     by_alias: Whether to serialize using field aliases.     exclude_unset: Whether to exclude fields that have not been explicitly set.     exclude_defaults: Whether to exclude fields that are set to their default value.     exclude_none: Whether to exclude fields that have a value of `None`.     exclude_computed_fields: Whether to exclude computed fields.         While this can be useful for round-tripping, it is usually recommended to use the dedicated         `round_trip` parameter instead.     round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].     warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,         "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].     fallback: A function to call when an unknown value is encountered. If not provided,         a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.     serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.     polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.   Returns:     A JSON string representation of the model. model_post_init(self, context: 'Any', /) -> 'None' Override this method to perform additional initialization after `__init__` and `model_construct`. This is useful if you want to do some validation that requires the entire model to be initialized. Class methods inherited from pydantic.main.BaseModel: __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef' from pydantic._internal._model_construction.ModelMetaclass __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema' from pydantic._internal._model_construction.ModelMetaclass __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue' from pydantic._internal._model_construction.ModelMetaclass Hook into generating the model's JSON schema.   Args:     core_schema: A `pydantic-core` CoreSchema.         You can ignore this argument and call the handler with a new CoreSchema,         wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),         or just call the handler with the original schema.     handler: Call into Pydantic's internal JSON schema generation.         This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema         generation fails.         Since this gets called by `BaseModel.model_json_schema` you can override the         `schema_generator` argument to that function to change JSON schema generation globally         for a type.   Returns:     A JSON schema, as a Python object. __pydantic_init_subclass__(**kwargs: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass` only after basic class initialization is complete. In particular, attributes like `model_fields` will be present when this is called, but forward annotations are not guaranteed to be resolved yet, meaning that creating an instance of the class may fail.   This is necessary because `__init_subclass__` will always be called by `type.__new__`, and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that `type.__new__` was called in such a manner that the class would already be sufficiently initialized.   This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely, any kwargs passed to the class definition that aren't used internally by Pydantic.   Args:     **kwargs: Any keyword arguments passed to the class definition that aren't used internally         by Pydantic.   Note:     You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]     instead, which is called once the class and its fields are fully initialized and ready for validation. __pydantic_on_complete__() -> 'None' from pydantic._internal._model_construction.ModelMetaclass This is called once the class and its fields are fully initialized and ready to be used.   This typically happens when the class is created (just before [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass), except when forward annotations are used that could not immediately be resolved. In that case, it will be called later, when the model is rebuilt automatically or explicitly using [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild]. construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass from_orm(obj: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Creates a new instance of the `Model` class with validated data.   Creates a new model setting `__dict__` and `__pydantic_fields_set__` from trusted or pre-validated data. Default values are respected, but no other validation is performed.   !!! note     `model_construct()` generally respects the `model_config.extra` setting on the provided model.     That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`     and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.     Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in     an error if extra values are passed, but they will be ignored.   Args:     _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,         this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.         Otherwise, the field names from the `values` argument will be used.     values: Trusted or pre-validated data dictionary.   Returns:     A new instance of the `Model` class with validated data. model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]' from pydantic._internal._model_construction.ModelMetaclass Generates a JSON schema for a model class.   Args:     by_alias: Whether to use attribute aliases or not.     ref_template: The reference template.     union_format: The format to use when combining schemas from unions together. Can be one of:           - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)         keyword to combine schemas (the default).         - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)         keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive         type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to         `any_of`.     schema_generator: To override the logic used to generate the JSON schema, as a subclass of         `GenerateJsonSchema` with your desired modifications     mode: The mode in which to generate the schema.   Returns:     The JSON schema for the given model class. model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str' from pydantic._internal._model_construction.ModelMetaclass Compute the class name for parametrizations of generic classes.   This method can be overridden to achieve a custom naming scheme for generic BaseModels.   Args:     params: Tuple of types of the class. Given a generic class         `Model` with 2 type variables and a concrete model `Model[str, int]`,         the value `(str, int)` would be passed to `params`.   Returns:     String representing the new class where `params` are passed to `cls` as type variables.   Raises:     TypeError: Raised when trying to generate concrete names for non-generic models. model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None' from pydantic._internal._model_construction.ModelMetaclass Try to rebuild the pydantic-core schema for the model.   This may be necessary when one of the annotations is a ForwardRef which could not be resolved during the initial attempt to build the schema, and automatic rebuilding fails.   Args:     force: Whether to force the rebuilding of the model schema, defaults to `False`.     raise_errors: Whether to raise errors, defaults to `True`.     _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.     _types_namespace: The types namespace, defaults to `None`.   Returns:     Returns `None` if the schema is already "complete" and rebuilding was not required.     If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`. model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Validate a pydantic model instance.   Args:     obj: The object to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     from_attributes: Whether to extract data from object attributes.     context: Additional context to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Raises:     ValidationError: If the object could not be validated.   Returns:     The validated model instance. model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass !!! abstract "Usage Documentation"     [JSON Parsing](../concepts/json.md#json-parsing)   Validate the given JSON data against the Pydantic model.   Args:     json_data: The JSON data to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     context: Extra variables to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Returns:     The validated Pydantic model.   Raises:     ValidationError: If `json_data` is not a JSON string or the object could not be validated. model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Validate the given object with string data against the Pydantic model.   Args:     obj: The object containing string data to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     context: Extra variables to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Returns:     The validated Pydantic model. parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass parse_obj(obj: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]' from pydantic._internal._model_construction.ModelMetaclass schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str' from pydantic._internal._model_construction.ModelMetaclass update_forward_refs(**localns: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass validate(value: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Readonly properties inherited from pydantic.main.BaseModel: __fields_set__ model_extra Get extra fields set during validation.   Returns:     A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`. model_fields_set Returns the set of fields that have been explicitly set on this model instance.   Returns:     A set of strings representing the fields that have been set,         i.e. that were not filled from defaults. Data descriptors inherited from pydantic.main.BaseModel: __dict__ dictionary for instance variables (if defined) __pydantic_extra__ __pydantic_fields_set__ __pydantic_private__ Data and other attributes inherited from pydantic.main.BaseModel: __hash__ = None __pydantic_root_model__ = False model_computed_fields = {} model_fields = {'id': FieldInfo(annotation=str, required=True), 'message': FieldInfo(annotation=str, required=True), 'name': FieldInfo(annotation=str, required=True), 'scenario': FieldInfo(annotation=str, required=True), 'version': FieldInfo(annotation=str, required=True)}   class PromptTemplate(pydantic.main.BaseModel)     PromptTemplate(*, role: str, content: Union[str, List[Union[str, gen_ai_hub.orchestration_v2.models.multimodal_items.TextPart, gen_ai_hub.orchestration_v2.models.multimodal_items.ImagePart, gen_ai_hub.orchestration_v2.models.multimodal_items.ImageItem]]]) -&gt; None   Represents a prompt template.   Args:     role: The role of the prompt template.       content: The content of the prompt template.     Method resolution order: PromptTemplate pydantic.main.BaseModel builtins.object Class methods defined here: content_validation(content) from pydantic._internal._model_construction.ModelMetaclass Validates and maps the content field to the appropriate types. Data descriptors defined here: __weakref__ list of weak references to the object (if defined) Data and other attributes defined here: __abstractmethods__ = frozenset() __annotations__ = {'content': typing.Union[str, typing.List[typing.Union[str, ...estration_v2.models.multimodal_items.ImageItem]]], 'role': <class 'str'>} __class_vars__ = set() __private_attributes__ = {} __pydantic_complete__ = True __pydantic_computed_fields__ = {} __pydantic_core_schema__ = {'cls': <class 'gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplate'>, 'config': {'title': 'PromptTemplate'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...registry.models.prompt_template.PromptTemplate'>>]}, 'ref': 'gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplate:140540951190128', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'content': {'metadata': {}, 'schema': {'function': {'function': <bound method PromptTemplate.content_validation ...registry.models.prompt_template.PromptTemplate'>>, 'type': 'no-info'}, 'schema': {'choices': [...], 'type': 'union'}, 'type': 'function-before'}, 'type': 'model-field'}, 'role': {'metadata': {}, 'schema': {'type': 'str'}, 'type': 'model-field'}}, 'model_name': 'PromptTemplate', 'type': 'model-fields'}, 'type': 'model'} __pydantic_custom_init__ = False __pydantic_decorators__ = DecoratorInfos(validators={}, field_validators={...zers={}, model_validators={}, computed_fields={}) __pydantic_extra_info__ = None __pydantic_fields__ = {'content': FieldInfo(annotation=Union[str, List[Union[str, TextPart, ImagePart, ImageItem]]], required=True), 'role': FieldInfo(annotation=str, required=True)} __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'parameters': ()} __pydantic_parent_namespace__ = None __pydantic_post_init__ = None __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTrampoli...led_from_config: false, }, ), definitions=[]) __pydantic_setattr_handlers__ = {} __pydantic_validator__ = SchemaValidator(title="PromptTemplate", validato...e", }, ), definitions=[], cache_strings=True) __signature__ = <Signature (*, role: str, content: Union[str, Li...v2.models.multimodal_items.ImageItem]]]) -> None> model_config = {} Methods inherited from pydantic.main.BaseModel: __copy__(self) -> 'Self' Returns a shallow copy of the model. __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self' Returns a deep copy of the model. __delattr__(self, item: 'str') -> 'Any' Implement delattr(self, name). __eq__(self, other: 'Any') -> 'bool' Return self==value. __getattr__(self, item: 'str') -> 'Any' __getstate__(self) -> 'dict[Any, Any]' __init__(self, /, **data: 'Any') -> 'None' Create a new model by parsing and validating input data from keyword arguments.   Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.   `self` is explicitly positional-only to allow `self` as a field name. __iter__(self) -> 'TupleGenerator' So `dict(model)` works. __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects. __replace__(self, **changes: 'Any') -> 'Self' # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block: __repr__(self) -> 'str' Return repr(self). __repr_args__(self) -> '_repr.ReprArgs' __repr_name__(self) -> 'str' Name of the instance's class, used in __repr__. __repr_recursion__(self, object: 'Any') -> 'str' Returns the string representation of a recursive object. __repr_str__(self, join_str: 'str') -> 'str' __rich_repr__(self) -> 'RichReprResult' Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects. __setattr__(self, name: 'str', value: 'Any') -> 'None' Implement setattr(self, name, value). __setstate__(self, state: 'dict[Any, Any]') -> 'None' __str__(self) -> 'str' Return str(self). copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self' Returns a copy of the model.   !!! warning "Deprecated"     This method is now deprecated; use `model_copy` instead.   If you need `include` or `exclude`, use:   ```python {test="skip" lint="skip"} data = self.model_dump(include=include, exclude=exclude, round_trip=True) data = {**data, **(update or {})} copied = self.model_validate(data) ```   Args:     include: Optional set or mapping specifying which fields to include in the copied model.     exclude: Optional set or mapping specifying which fields to exclude in the copied model.     update: Optional dictionary of field-value pairs to override field values in the copied model.     deep: If True, the values of fields that are Pydantic models will be deep-copied.   Returns:     A copy of the model with included, excluded and updated fields as specified. dict(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False) -> 'Dict[str, Any]' json(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str' model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self' !!! abstract "Usage Documentation"     [`model_copy`](../concepts/models.md#model-copy)   Returns a copy of the model.   !!! note     The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This     might have unexpected side effects if you store anything in it, on top of the model     fields (e.g. the value of [cached properties][functools.cached_property]).   Args:     update: Values to change/add in the new model. Note: the data is not validated         before creating the new model. You should trust this data.     deep: Set to `True` to make a deep copy of the model.   Returns:     New model instance. model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]' !!! abstract "Usage Documentation"     [`model_dump`](../concepts/serialization.md#python-mode)   Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.   Args:     mode: The mode in which `to_python` should run.         If mode is 'json', the output will only contain JSON serializable types.         If mode is 'python', the output may contain non-JSON-serializable Python objects.     include: A set of fields to include in the output.     exclude: A set of fields to exclude from the output.     context: Additional context to pass to the serializer.     by_alias: Whether to use the field's alias in the dictionary key if defined.     exclude_unset: Whether to exclude fields that have not been explicitly set.     exclude_defaults: Whether to exclude fields that are set to their default value.     exclude_none: Whether to exclude fields that have a value of `None`.     exclude_computed_fields: Whether to exclude computed fields.         While this can be useful for round-tripping, it is usually recommended to use the dedicated         `round_trip` parameter instead.     round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].     warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,         "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].     fallback: A function to call when an unknown value is encountered. If not provided,         a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.     serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.     polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.   Returns:     A dictionary representation of the model. model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str' !!! abstract "Usage Documentation"     [`model_dump_json`](../concepts/serialization.md#json-mode)   Generates a JSON representation of the model using Pydantic's `to_json` method.   Args:     indent: Indentation to use in the JSON output. If None is passed, the output will be compact.     ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.         If `False` (the default), these characters will be output as-is.     include: Field(s) to include in the JSON output.     exclude: Field(s) to exclude from the JSON output.     context: Additional context to pass to the serializer.     by_alias: Whether to serialize using field aliases.     exclude_unset: Whether to exclude fields that have not been explicitly set.     exclude_defaults: Whether to exclude fields that are set to their default value.     exclude_none: Whether to exclude fields that have a value of `None`.     exclude_computed_fields: Whether to exclude computed fields.         While this can be useful for round-tripping, it is usually recommended to use the dedicated         `round_trip` parameter instead.     round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].     warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,         "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].     fallback: A function to call when an unknown value is encountered. If not provided,         a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.     serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.     polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.   Returns:     A JSON string representation of the model. model_post_init(self, context: 'Any', /) -> 'None' Override this method to perform additional initialization after `__init__` and `model_construct`. This is useful if you want to do some validation that requires the entire model to be initialized. Class methods inherited from pydantic.main.BaseModel: __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef' from pydantic._internal._model_construction.ModelMetaclass __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema' from pydantic._internal._model_construction.ModelMetaclass __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue' from pydantic._internal._model_construction.ModelMetaclass Hook into generating the model's JSON schema.   Args:     core_schema: A `pydantic-core` CoreSchema.         You can ignore this argument and call the handler with a new CoreSchema,         wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),         or just call the handler with the original schema.     handler: Call into Pydantic's internal JSON schema generation.         This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema         generation fails.         Since this gets called by `BaseModel.model_json_schema` you can override the         `schema_generator` argument to that function to change JSON schema generation globally         for a type.   Returns:     A JSON schema, as a Python object. __pydantic_init_subclass__(**kwargs: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass` only after basic class initialization is complete. In particular, attributes like `model_fields` will be present when this is called, but forward annotations are not guaranteed to be resolved yet, meaning that creating an instance of the class may fail.   This is necessary because `__init_subclass__` will always be called by `type.__new__`, and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that `type.__new__` was called in such a manner that the class would already be sufficiently initialized.   This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely, any kwargs passed to the class definition that aren't used internally by Pydantic.   Args:     **kwargs: Any keyword arguments passed to the class definition that aren't used internally         by Pydantic.   Note:     You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]     instead, which is called once the class and its fields are fully initialized and ready for validation. __pydantic_on_complete__() -> 'None' from pydantic._internal._model_construction.ModelMetaclass This is called once the class and its fields are fully initialized and ready to be used.   This typically happens when the class is created (just before [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass), except when forward annotations are used that could not immediately be resolved. In that case, it will be called later, when the model is rebuilt automatically or explicitly using [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild]. construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass from_orm(obj: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Creates a new instance of the `Model` class with validated data.   Creates a new model setting `__dict__` and `__pydantic_fields_set__` from trusted or pre-validated data. Default values are respected, but no other validation is performed.   !!! note     `model_construct()` generally respects the `model_config.extra` setting on the provided model.     That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`     and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.     Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in     an error if extra values are passed, but they will be ignored.   Args:     _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,         this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.         Otherwise, the field names from the `values` argument will be used.     values: Trusted or pre-validated data dictionary.   Returns:     A new instance of the `Model` class with validated data. model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]' from pydantic._internal._model_construction.ModelMetaclass Generates a JSON schema for a model class.   Args:     by_alias: Whether to use attribute aliases or not.     ref_template: The reference template.     union_format: The format to use when combining schemas from unions together. Can be one of:           - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)         keyword to combine schemas (the default).         - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)         keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive         type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to         `any_of`.     schema_generator: To override the logic used to generate the JSON schema, as a subclass of         `GenerateJsonSchema` with your desired modifications     mode: The mode in which to generate the schema.   Returns:     The JSON schema for the given model class. model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str' from pydantic._internal._model_construction.ModelMetaclass Compute the class name for parametrizations of generic classes.   This method can be overridden to achieve a custom naming scheme for generic BaseModels.   Args:     params: Tuple of types of the class. Given a generic class         `Model` with 2 type variables and a concrete model `Model[str, int]`,         the value `(str, int)` would be passed to `params`.   Returns:     String representing the new class where `params` are passed to `cls` as type variables.   Raises:     TypeError: Raised when trying to generate concrete names for non-generic models. model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None' from pydantic._internal._model_construction.ModelMetaclass Try to rebuild the pydantic-core schema for the model.   This may be necessary when one of the annotations is a ForwardRef which could not be resolved during the initial attempt to build the schema, and automatic rebuilding fails.   Args:     force: Whether to force the rebuilding of the model schema, defaults to `False`.     raise_errors: Whether to raise errors, defaults to `True`.     _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.     _types_namespace: The types namespace, defaults to `None`.   Returns:     Returns `None` if the schema is already "complete" and rebuilding was not required.     If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`. model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Validate a pydantic model instance.   Args:     obj: The object to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     from_attributes: Whether to extract data from object attributes.     context: Additional context to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Raises:     ValidationError: If the object could not be validated.   Returns:     The validated model instance. model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass !!! abstract "Usage Documentation"     [JSON Parsing](../concepts/json.md#json-parsing)   Validate the given JSON data against the Pydantic model.   Args:     json_data: The JSON data to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     context: Extra variables to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Returns:     The validated Pydantic model.   Raises:     ValidationError: If `json_data` is not a JSON string or the object could not be validated. model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Validate the given object with string data against the Pydantic model.   Args:     obj: The object containing string data to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     context: Extra variables to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Returns:     The validated Pydantic model. parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass parse_obj(obj: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]' from pydantic._internal._model_construction.ModelMetaclass schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str' from pydantic._internal._model_construction.ModelMetaclass update_forward_refs(**localns: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass validate(value: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Readonly properties inherited from pydantic.main.BaseModel: __fields_set__ model_extra Get extra fields set during validation.   Returns:     A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`. model_fields_set Returns the set of fields that have been explicitly set on this model instance.   Returns:     A set of strings representing the fields that have been set,         i.e. that were not filled from defaults. Data descriptors inherited from pydantic.main.BaseModel: __dict__ dictionary for instance variables (if defined) __pydantic_extra__ __pydantic_fields_set__ __pydantic_private__ Data and other attributes inherited from pydantic.main.BaseModel: __hash__ = None __pydantic_root_model__ = False model_computed_fields = {} model_fields = {'content': FieldInfo(annotation=Union[str, List[Union[str, TextPart, ImagePart, ImageItem]]], required=True), 'role': FieldInfo(annotation=str, required=True)}   class PromptTemplateClient(PromptRegistryClient)     PromptTemplateClient(proxy_client: Optional[gen_ai_hub.proxy.gen_ai_hub_proxy.client.GenAIHubProxyClient] = None)   Client for interacting with the Prompt Registry Prompt Template API.   https://api.sap.com/api/PROMPT_REGISTRY_API/overview     Method resolution order: PromptTemplateClient PromptRegistryClient abc.ABC builtins.object Methods defined here: create_prompt_template(self, name: str, version: str, scenario: str, prompt_template_spec: gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateSpec) -> gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplatePostResponse Create or update a prompt template.   :param name: the name of the prompt template. :type name: str :param version: the version of the prompt template. :type version: str :param scenario: the scenario name of the prompt template. :type scenario: str :param prompt_template_spec: the specification of the prompt template. :type prompt_template_spec: PromptTemplateSpec :return: A PromptTemplatePostResponse object. :rtype: PromptTemplatePostResponse delete_prompt_template_by_id(self, template_id: str) -> gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateDeleteResponse Delete a specific version of the prompt template by ID.   :param template_id: The ID of the prompt template to delete. :type template_id: str :return: A PromptTemplateDeleteResponse object. :rtype: PromptTemplateDeleteResponse export_prompt_template(self, template_id: str) -> bytes Export a design time template in a declarative compatible yaml file. Supports only single file export.   :param template_id: The id of the prompt template to export. :type template_id: str :return: bytes: The content of the exported file :rtype: bytes fill_prompt_template(self, scenario: str, name: str, version: str, input_params: dict, metadata: bool = False) -> gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateSubstitutionResponse Replace the placeholders of the prompt template referenced via scenario-name-version  with user provided values.   :param scenario: the scenario name of the prompt template. :type scenario: str :param name: the name of the prompt template. :type name: str :param version: the version of the prompt template. :type version: str :param input_params: User provided values to replace the placeholders of the prompt template. :type input_params: dict :param metadata: False(default), True return resource object with all details. :type metadata: bool, optional :return: A PromptTemplateSubstitutionResponse object. :rtype: PromptTemplateSubstitutionResponse fill_prompt_template_by_id(self, template_id: str, input_params: dict, metadata: bool = False) -> gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateSubstitutionResponse Replace the placeholders of the prompt template referenced via template_id with user provided values.   :param template_id: The ID of the prompt template. :type template_id: str :param input_params: User provided values to replace the placeholders of the prompt template. :type input_params: dict :param metadata: False(default), True return resource object with all details. :type metadata: bool, optional :return: A PromptTemplateSubstitutionResponse object. :rtype: PromptTemplateSubstitutionResponse get_prompt_template_by_id(self, template_id: str) -> gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateGetResponse Retrieve a specific version of the prompt template by ID.   :param template_id: The ID of the prompt template to retrieve. :type template_id: str :return: A PromptTemplateGetResponse object. :rtype: PromptTemplateGetResponse get_prompt_template_history(self, scenario: str, name: str, version: str) -> gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateListResponse Retrieve the history of edits to the prompt template. Only for imperative managed prompt templates.   :param scenario: The scenario name of the prompt template. :type scenario: str :param name: The name of the prompt template. :type name: str :param version: The version ID of the prompt template. :type version: str :return: A PromptTemplateListResponse object. :rtype: PromptTemplateListResponse get_prompt_templates(self, scenario: str, name: str, version: str, retrieve: str = None, include_spec: bool = None) -> gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateListResponse Retrieve the latest version of every prompt template based on the filters.   :param scenario: the scenario name of the prompt template. :type scenario: str :param name: the name of the prompt template. :type name: str :param version: the version of the prompt template. :type version: str :param retrieve: both(default), imperative, declarative :type retrieve: str, optional :param include_spec: false(default), true :type include_spec: bool, optional :return: A PromptTemplateListResponse object. :rtype: PromptTemplateListResponse import_prompt_template(self, file: bytes) -> gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplatePostResponse Import a runtime/declarative prompt template into the design time environment.   :param file: binary file content :type file: bytes :return: A PromptTemplatePostResponse object. :rtype: PromptTemplatePostResponse Data and other attributes defined here: __abstractmethods__ = frozenset() __annotations__ = {} Methods inherited from PromptRegistryClient: __init__(self, proxy_client: Optional[gen_ai_hub.proxy.gen_ai_hub_proxy.client.GenAIHubProxyClient] = None) Initializes the PromptRegistryClient.   :param proxy_client: Optional proxy client to use for requests. :type proxy_client: Optional[GenAIHubProxyClient], optional Data descriptors inherited from PromptRegistryClient: __dict__ dictionary for instance variables (if defined) __weakref__ list of weak references to the object (if defined)   class PromptTemplateDeleteResponse(pydantic.main.BaseModel)     PromptTemplateDeleteResponse(*, message: str) -&gt; None   Represents a response to a request to delete a prompt template.   Args:     message: The message of the response.     Method resolution order: PromptTemplateDeleteResponse pydantic.main.BaseModel builtins.object Data descriptors defined here: __weakref__ list of weak references to the object (if defined) Data and other attributes defined here: __abstractmethods__ = frozenset() __annotations__ = {'message': <class 'str'>} __class_vars__ = set() __private_attributes__ = {} __pydantic_complete__ = True __pydantic_computed_fields__ = {} __pydantic_core_schema__ = {'cls': <class 'gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateDeleteResponse'>, 'config': {'title': 'PromptTemplateDeleteResponse'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...s.prompt_template.PromptTemplateDeleteResponse'>>]}, 'ref': 'gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateDeleteResponse:140540950957040', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'message': {'metadata': {}, 'schema': {'type': 'str'}, 'type': 'model-field'}}, 'model_name': 'PromptTemplateDeleteResponse', 'type': 'model-fields'}, 'type': 'model'} __pydantic_custom_init__ = False __pydantic_decorators__ = DecoratorInfos(validators={}, field_validators={...zers={}, model_validators={}, computed_fields={}) __pydantic_extra_info__ = None __pydantic_fields__ = {'message': FieldInfo(annotation=str, required=True)} __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'parameters': ()} __pydantic_parent_namespace__ = None __pydantic_post_init__ = None __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTrampoli...led_from_config: false, }, ), definitions=[]) __pydantic_setattr_handlers__ = {} __pydantic_validator__ = SchemaValidator(title="PromptTemplateDeleteRespo...e", }, ), definitions=[], cache_strings=True) __signature__ = <Signature (*, message: str) -> None> model_config = {} Methods inherited from pydantic.main.BaseModel: __copy__(self) -> 'Self' Returns a shallow copy of the model. __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self' Returns a deep copy of the model. __delattr__(self, item: 'str') -> 'Any' Implement delattr(self, name). __eq__(self, other: 'Any') -> 'bool' Return self==value. __getattr__(self, item: 'str') -> 'Any' __getstate__(self) -> 'dict[Any, Any]' __init__(self, /, **data: 'Any') -> 'None' Create a new model by parsing and validating input data from keyword arguments.   Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.   `self` is explicitly positional-only to allow `self` as a field name. __iter__(self) -> 'TupleGenerator' So `dict(model)` works. __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects. __replace__(self, **changes: 'Any') -> 'Self' # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block: __repr__(self) -> 'str' Return repr(self). __repr_args__(self) -> '_repr.ReprArgs' __repr_name__(self) -> 'str' Name of the instance's class, used in __repr__. __repr_recursion__(self, object: 'Any') -> 'str' Returns the string representation of a recursive object. __repr_str__(self, join_str: 'str') -> 'str' __rich_repr__(self) -> 'RichReprResult' Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects. __setattr__(self, name: 'str', value: 'Any') -> 'None' Implement setattr(self, name, value). __setstate__(self, state: 'dict[Any, Any]') -> 'None' __str__(self) -> 'str' Return str(self). copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self' Returns a copy of the model.   !!! warning "Deprecated"     This method is now deprecated; use `model_copy` instead.   If you need `include` or `exclude`, use:   ```python {test="skip" lint="skip"} data = self.model_dump(include=include, exclude=exclude, round_trip=True) data = {**data, **(update or {})} copied = self.model_validate(data) ```   Args:     include: Optional set or mapping specifying which fields to include in the copied model.     exclude: Optional set or mapping specifying which fields to exclude in the copied model.     update: Optional dictionary of field-value pairs to override field values in the copied model.     deep: If True, the values of fields that are Pydantic models will be deep-copied.   Returns:     A copy of the model with included, excluded and updated fields as specified. dict(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False) -> 'Dict[str, Any]' json(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str' model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self' !!! abstract "Usage Documentation"     [`model_copy`](../concepts/models.md#model-copy)   Returns a copy of the model.   !!! note     The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This     might have unexpected side effects if you store anything in it, on top of the model     fields (e.g. the value of [cached properties][functools.cached_property]).   Args:     update: Values to change/add in the new model. Note: the data is not validated         before creating the new model. You should trust this data.     deep: Set to `True` to make a deep copy of the model.   Returns:     New model instance. model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]' !!! abstract "Usage Documentation"     [`model_dump`](../concepts/serialization.md#python-mode)   Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.   Args:     mode: The mode in which `to_python` should run.         If mode is 'json', the output will only contain JSON serializable types.         If mode is 'python', the output may contain non-JSON-serializable Python objects.     include: A set of fields to include in the output.     exclude: A set of fields to exclude from the output.     context: Additional context to pass to the serializer.     by_alias: Whether to use the field's alias in the dictionary key if defined.     exclude_unset: Whether to exclude fields that have not been explicitly set.     exclude_defaults: Whether to exclude fields that are set to their default value.     exclude_none: Whether to exclude fields that have a value of `None`.     exclude_computed_fields: Whether to exclude computed fields.         While this can be useful for round-tripping, it is usually recommended to use the dedicated         `round_trip` parameter instead.     round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].     warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,         "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].     fallback: A function to call when an unknown value is encountered. If not provided,         a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.     serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.     polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.   Returns:     A dictionary representation of the model. model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str' !!! abstract "Usage Documentation"     [`model_dump_json`](../concepts/serialization.md#json-mode)   Generates a JSON representation of the model using Pydantic's `to_json` method.   Args:     indent: Indentation to use in the JSON output. If None is passed, the output will be compact.     ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.         If `False` (the default), these characters will be output as-is.     include: Field(s) to include in the JSON output.     exclude: Field(s) to exclude from the JSON output.     context: Additional context to pass to the serializer.     by_alias: Whether to serialize using field aliases.     exclude_unset: Whether to exclude fields that have not been explicitly set.     exclude_defaults: Whether to exclude fields that are set to their default value.     exclude_none: Whether to exclude fields that have a value of `None`.     exclude_computed_fields: Whether to exclude computed fields.         While this can be useful for round-tripping, it is usually recommended to use the dedicated         `round_trip` parameter instead.     round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].     warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,         "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].     fallback: A function to call when an unknown value is encountered. If not provided,         a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.     serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.     polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.   Returns:     A JSON string representation of the model. model_post_init(self, context: 'Any', /) -> 'None' Override this method to perform additional initialization after `__init__` and `model_construct`. This is useful if you want to do some validation that requires the entire model to be initialized. Class methods inherited from pydantic.main.BaseModel: __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef' from pydantic._internal._model_construction.ModelMetaclass __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema' from pydantic._internal._model_construction.ModelMetaclass __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue' from pydantic._internal._model_construction.ModelMetaclass Hook into generating the model's JSON schema.   Args:     core_schema: A `pydantic-core` CoreSchema.         You can ignore this argument and call the handler with a new CoreSchema,         wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),         or just call the handler with the original schema.     handler: Call into Pydantic's internal JSON schema generation.         This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema         generation fails.         Since this gets called by `BaseModel.model_json_schema` you can override the         `schema_generator` argument to that function to change JSON schema generation globally         for a type.   Returns:     A JSON schema, as a Python object. __pydantic_init_subclass__(**kwargs: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass` only after basic class initialization is complete. In particular, attributes like `model_fields` will be present when this is called, but forward annotations are not guaranteed to be resolved yet, meaning that creating an instance of the class may fail.   This is necessary because `__init_subclass__` will always be called by `type.__new__`, and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that `type.__new__` was called in such a manner that the class would already be sufficiently initialized.   This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely, any kwargs passed to the class definition that aren't used internally by Pydantic.   Args:     **kwargs: Any keyword arguments passed to the class definition that aren't used internally         by Pydantic.   Note:     You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]     instead, which is called once the class and its fields are fully initialized and ready for validation. __pydantic_on_complete__() -> 'None' from pydantic._internal._model_construction.ModelMetaclass This is called once the class and its fields are fully initialized and ready to be used.   This typically happens when the class is created (just before [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass), except when forward annotations are used that could not immediately be resolved. In that case, it will be called later, when the model is rebuilt automatically or explicitly using [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild]. construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass from_orm(obj: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Creates a new instance of the `Model` class with validated data.   Creates a new model setting `__dict__` and `__pydantic_fields_set__` from trusted or pre-validated data. Default values are respected, but no other validation is performed.   !!! note     `model_construct()` generally respects the `model_config.extra` setting on the provided model.     That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`     and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.     Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in     an error if extra values are passed, but they will be ignored.   Args:     _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,         this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.         Otherwise, the field names from the `values` argument will be used.     values: Trusted or pre-validated data dictionary.   Returns:     A new instance of the `Model` class with validated data. model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]' from pydantic._internal._model_construction.ModelMetaclass Generates a JSON schema for a model class.   Args:     by_alias: Whether to use attribute aliases or not.     ref_template: The reference template.     union_format: The format to use when combining schemas from unions together. Can be one of:           - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)         keyword to combine schemas (the default).         - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)         keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive         type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to         `any_of`.     schema_generator: To override the logic used to generate the JSON schema, as a subclass of         `GenerateJsonSchema` with your desired modifications     mode: The mode in which to generate the schema.   Returns:     The JSON schema for the given model class. model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str' from pydantic._internal._model_construction.ModelMetaclass Compute the class name for parametrizations of generic classes.   This method can be overridden to achieve a custom naming scheme for generic BaseModels.   Args:     params: Tuple of types of the class. Given a generic class         `Model` with 2 type variables and a concrete model `Model[str, int]`,         the value `(str, int)` would be passed to `params`.   Returns:     String representing the new class where `params` are passed to `cls` as type variables.   Raises:     TypeError: Raised when trying to generate concrete names for non-generic models. model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None' from pydantic._internal._model_construction.ModelMetaclass Try to rebuild the pydantic-core schema for the model.   This may be necessary when one of the annotations is a ForwardRef which could not be resolved during the initial attempt to build the schema, and automatic rebuilding fails.   Args:     force: Whether to force the rebuilding of the model schema, defaults to `False`.     raise_errors: Whether to raise errors, defaults to `True`.     _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.     _types_namespace: The types namespace, defaults to `None`.   Returns:     Returns `None` if the schema is already "complete" and rebuilding was not required.     If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`. model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Validate a pydantic model instance.   Args:     obj: The object to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     from_attributes: Whether to extract data from object attributes.     context: Additional context to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Raises:     ValidationError: If the object could not be validated.   Returns:     The validated model instance. model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass !!! abstract "Usage Documentation"     [JSON Parsing](../concepts/json.md#json-parsing)   Validate the given JSON data against the Pydantic model.   Args:     json_data: The JSON data to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     context: Extra variables to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Returns:     The validated Pydantic model.   Raises:     ValidationError: If `json_data` is not a JSON string or the object could not be validated. model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Validate the given object with string data against the Pydantic model.   Args:     obj: The object containing string data to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     context: Extra variables to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Returns:     The validated Pydantic model. parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass parse_obj(obj: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]' from pydantic._internal._model_construction.ModelMetaclass schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str' from pydantic._internal._model_construction.ModelMetaclass update_forward_refs(**localns: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass validate(value: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Readonly properties inherited from pydantic.main.BaseModel: __fields_set__ model_extra Get extra fields set during validation.   Returns:     A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`. model_fields_set Returns the set of fields that have been explicitly set on this model instance.   Returns:     A set of strings representing the fields that have been set,         i.e. that were not filled from defaults. Data descriptors inherited from pydantic.main.BaseModel: __dict__ dictionary for instance variables (if defined) __pydantic_extra__ __pydantic_fields_set__ __pydantic_private__ Data and other attributes inherited from pydantic.main.BaseModel: __hash__ = None __pydantic_root_model__ = False model_computed_fields = {} model_fields = {'message': FieldInfo(annotation=str, required=True)}   class PromptTemplateGetResponse(pydantic.main.BaseModel)     PromptTemplateGetResponse(*, id: str, name: str, version: str, scenario: str, creation_timestamp: Optional[str] = None, managed_by: Optional[str] = None, is_version_head: Optional[bool] = None, spec: Optional[gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateSpec] = None) -&gt; None   Represents a response to a request to get a prompt template.   Args:     id: The ID of the prompt template.       name: The name of the prompt template.       version: The version of the prompt template.       scenario: The scenario of the prompt template.       creation_timestamp: The creation timestamp of the prompt template.       managed_by: The manager of the prompt template.       is_version_head: Whether the version is the head version.       spec: The specification of the prompt template.     Method resolution order: PromptTemplateGetResponse pydantic.main.BaseModel builtins.object Data descriptors defined here: __weakref__ list of weak references to the object (if defined) Data and other attributes defined here: __abstractmethods__ = frozenset() __annotations__ = {'creation_timestamp': typing.Optional[str], 'id': <class 'str'>, 'is_version_head': typing.Optional[bool], 'managed_by': typing.Optional[str], 'name': <class 'str'>, 'scenario': <class 'str'>, 'spec': typing.Optional[gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateSpec], 'version': <class 'str'>} __class_vars__ = set() __private_attributes__ = {} __pydantic_complete__ = True __pydantic_computed_fields__ = {} __pydantic_core_schema__ = {'cls': <class 'gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateGetResponse'>, 'config': {'title': 'PromptTemplateGetResponse'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...dels.prompt_template.PromptTemplateGetResponse'>>]}, 'ref': 'gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateGetResponse:140540951193152', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'creation_timestamp': {'metadata': {}, 'schema': {'default': None, 'schema': {'schema': {...}, 'type': 'nullable'}, 'type': 'default'}, 'type': 'model-field'}, 'id': {'metadata': {}, 'schema': {'type': 'str'}, 'type': 'model-field'}, 'is_version_head': {'metadata': {}, 'schema': {'default': None, 'schema': {'schema': {...}, 'type': 'nullable'}, 'type': 'default'}, 'type': 'model-field'}, 'managed_by': {'metadata': {}, 'schema': {'default': None, 'schema': {'schema': {...}, 'type': 'nullable'}, 'type': 'default'}, 'type': 'model-field'}, 'name': {'metadata': {}, 'schema': {'type': 'str'}, 'type': 'model-field'}, 'scenario': {'metadata': {}, 'schema': {'type': 'str'}, 'type': 'model-field'}, 'spec': {'metadata': {}, 'schema': {'default': None, 'schema': {'schema': {...}, 'type': 'nullable'}, 'type': 'default'}, 'type': 'model-field'}, 'version': {'metadata': {}, 'schema': {'type': 'str'}, 'type': 'model-field'}}, 'model_name': 'PromptTemplateGetResponse', 'type': 'model-fields'}, 'type': 'model'} __pydantic_custom_init__ = False __pydantic_decorators__ = DecoratorInfos(validators={}, field_validators={...zers={}, model_validators={}, computed_fields={}) __pydantic_extra_info__ = None __pydantic_fields__ = {'creation_timestamp': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'id': FieldInfo(annotation=str, required=True), 'is_version_head': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'managed_by': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'name': FieldInfo(annotation=str, required=True), 'scenario': FieldInfo(annotation=str, required=True), 'spec': FieldInfo(annotation=Union[PromptTemplateSpec, NoneType], required=False, default=None), 'version': FieldInfo(annotation=str, required=True)} __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'parameters': ()} __pydantic_parent_namespace__ = None __pydantic_post_init__ = None __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTrampoli...led_from_config: false, }, ), definitions=[]) __pydantic_setattr_handlers__ = {} __pydantic_validator__ = SchemaValidator(title="PromptTemplateGetResponse...e", }, ), definitions=[], cache_strings=True) __signature__ = <Signature (*, id: str, name: str, version: str,...mpt_template.PromptTemplateSpec] = None) -> None> model_config = {} Methods inherited from pydantic.main.BaseModel: __copy__(self) -> 'Self' Returns a shallow copy of the model. __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self' Returns a deep copy of the model. __delattr__(self, item: 'str') -> 'Any' Implement delattr(self, name). __eq__(self, other: 'Any') -> 'bool' Return self==value. __getattr__(self, item: 'str') -> 'Any' __getstate__(self) -> 'dict[Any, Any]' __init__(self, /, **data: 'Any') -> 'None' Create a new model by parsing and validating input data from keyword arguments.   Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.   `self` is explicitly positional-only to allow `self` as a field name. __iter__(self) -> 'TupleGenerator' So `dict(model)` works. __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects. __replace__(self, **changes: 'Any') -> 'Self' # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block: __repr__(self) -> 'str' Return repr(self). __repr_args__(self) -> '_repr.ReprArgs' __repr_name__(self) -> 'str' Name of the instance's class, used in __repr__. __repr_recursion__(self, object: 'Any') -> 'str' Returns the string representation of a recursive object. __repr_str__(self, join_str: 'str') -> 'str' __rich_repr__(self) -> 'RichReprResult' Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects. __setattr__(self, name: 'str', value: 'Any') -> 'None' Implement setattr(self, name, value). __setstate__(self, state: 'dict[Any, Any]') -> 'None' __str__(self) -> 'str' Return str(self). copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self' Returns a copy of the model.   !!! warning "Deprecated"     This method is now deprecated; use `model_copy` instead.   If you need `include` or `exclude`, use:   ```python {test="skip" lint="skip"} data = self.model_dump(include=include, exclude=exclude, round_trip=True) data = {**data, **(update or {})} copied = self.model_validate(data) ```   Args:     include: Optional set or mapping specifying which fields to include in the copied model.     exclude: Optional set or mapping specifying which fields to exclude in the copied model.     update: Optional dictionary of field-value pairs to override field values in the copied model.     deep: If True, the values of fields that are Pydantic models will be deep-copied.   Returns:     A copy of the model with included, excluded and updated fields as specified. dict(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False) -> 'Dict[str, Any]' json(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str' model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self' !!! abstract "Usage Documentation"     [`model_copy`](../concepts/models.md#model-copy)   Returns a copy of the model.   !!! note     The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This     might have unexpected side effects if you store anything in it, on top of the model     fields (e.g. the value of [cached properties][functools.cached_property]).   Args:     update: Values to change/add in the new model. Note: the data is not validated         before creating the new model. You should trust this data.     deep: Set to `True` to make a deep copy of the model.   Returns:     New model instance. model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]' !!! abstract "Usage Documentation"     [`model_dump`](../concepts/serialization.md#python-mode)   Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.   Args:     mode: The mode in which `to_python` should run.         If mode is 'json', the output will only contain JSON serializable types.         If mode is 'python', the output may contain non-JSON-serializable Python objects.     include: A set of fields to include in the output.     exclude: A set of fields to exclude from the output.     context: Additional context to pass to the serializer.     by_alias: Whether to use the field's alias in the dictionary key if defined.     exclude_unset: Whether to exclude fields that have not been explicitly set.     exclude_defaults: Whether to exclude fields that are set to their default value.     exclude_none: Whether to exclude fields that have a value of `None`.     exclude_computed_fields: Whether to exclude computed fields.         While this can be useful for round-tripping, it is usually recommended to use the dedicated         `round_trip` parameter instead.     round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].     warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,         "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].     fallback: A function to call when an unknown value is encountered. If not provided,         a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.     serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.     polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.   Returns:     A dictionary representation of the model. model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str' !!! abstract "Usage Documentation"     [`model_dump_json`](../concepts/serialization.md#json-mode)   Generates a JSON representation of the model using Pydantic's `to_json` method.   Args:     indent: Indentation to use in the JSON output. If None is passed, the output will be compact.     ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.         If `False` (the default), these characters will be output as-is.     include: Field(s) to include in the JSON output.     exclude: Field(s) to exclude from the JSON output.     context: Additional context to pass to the serializer.     by_alias: Whether to serialize using field aliases.     exclude_unset: Whether to exclude fields that have not been explicitly set.     exclude_defaults: Whether to exclude fields that are set to their default value.     exclude_none: Whether to exclude fields that have a value of `None`.     exclude_computed_fields: Whether to exclude computed fields.         While this can be useful for round-tripping, it is usually recommended to use the dedicated         `round_trip` parameter instead.     round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].     warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,         "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].     fallback: A function to call when an unknown value is encountered. If not provided,         a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.     serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.     polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.   Returns:     A JSON string representation of the model. model_post_init(self, context: 'Any', /) -> 'None' Override this method to perform additional initialization after `__init__` and `model_construct`. This is useful if you want to do some validation that requires the entire model to be initialized. Class methods inherited from pydantic.main.BaseModel: __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef' from pydantic._internal._model_construction.ModelMetaclass __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema' from pydantic._internal._model_construction.ModelMetaclass __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue' from pydantic._internal._model_construction.ModelMetaclass Hook into generating the model's JSON schema.   Args:     core_schema: A `pydantic-core` CoreSchema.         You can ignore this argument and call the handler with a new CoreSchema,         wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),         or just call the handler with the original schema.     handler: Call into Pydantic's internal JSON schema generation.         This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema         generation fails.         Since this gets called by `BaseModel.model_json_schema` you can override the         `schema_generator` argument to that function to change JSON schema generation globally         for a type.   Returns:     A JSON schema, as a Python object. __pydantic_init_subclass__(**kwargs: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass` only after basic class initialization is complete. In particular, attributes like `model_fields` will be present when this is called, but forward annotations are not guaranteed to be resolved yet, meaning that creating an instance of the class may fail.   This is necessary because `__init_subclass__` will always be called by `type.__new__`, and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that `type.__new__` was called in such a manner that the class would already be sufficiently initialized.   This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely, any kwargs passed to the class definition that aren't used internally by Pydantic.   Args:     **kwargs: Any keyword arguments passed to the class definition that aren't used internally         by Pydantic.   Note:     You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]     instead, which is called once the class and its fields are fully initialized and ready for validation. __pydantic_on_complete__() -> 'None' from pydantic._internal._model_construction.ModelMetaclass This is called once the class and its fields are fully initialized and ready to be used.   This typically happens when the class is created (just before [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass), except when forward annotations are used that could not immediately be resolved. In that case, it will be called later, when the model is rebuilt automatically or explicitly using [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild]. construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass from_orm(obj: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Creates a new instance of the `Model` class with validated data.   Creates a new model setting `__dict__` and `__pydantic_fields_set__` from trusted or pre-validated data. Default values are respected, but no other validation is performed.   !!! note     `model_construct()` generally respects the `model_config.extra` setting on the provided model.     That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`     and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.     Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in     an error if extra values are passed, but they will be ignored.   Args:     _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,         this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.         Otherwise, the field names from the `values` argument will be used.     values: Trusted or pre-validated data dictionary.   Returns:     A new instance of the `Model` class with validated data. model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]' from pydantic._internal._model_construction.ModelMetaclass Generates a JSON schema for a model class.   Args:     by_alias: Whether to use attribute aliases or not.     ref_template: The reference template.     union_format: The format to use when combining schemas from unions together. Can be one of:           - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)         keyword to combine schemas (the default).         - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)         keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive         type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to         `any_of`.     schema_generator: To override the logic used to generate the JSON schema, as a subclass of         `GenerateJsonSchema` with your desired modifications     mode: The mode in which to generate the schema.   Returns:     The JSON schema for the given model class. model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str' from pydantic._internal._model_construction.ModelMetaclass Compute the class name for parametrizations of generic classes.   This method can be overridden to achieve a custom naming scheme for generic BaseModels.   Args:     params: Tuple of types of the class. Given a generic class         `Model` with 2 type variables and a concrete model `Model[str, int]`,         the value `(str, int)` would be passed to `params`.   Returns:     String representing the new class where `params` are passed to `cls` as type variables.   Raises:     TypeError: Raised when trying to generate concrete names for non-generic models. model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None' from pydantic._internal._model_construction.ModelMetaclass Try to rebuild the pydantic-core schema for the model.   This may be necessary when one of the annotations is a ForwardRef which could not be resolved during the initial attempt to build the schema, and automatic rebuilding fails.   Args:     force: Whether to force the rebuilding of the model schema, defaults to `False`.     raise_errors: Whether to raise errors, defaults to `True`.     _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.     _types_namespace: The types namespace, defaults to `None`.   Returns:     Returns `None` if the schema is already "complete" and rebuilding was not required.     If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`. model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Validate a pydantic model instance.   Args:     obj: The object to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     from_attributes: Whether to extract data from object attributes.     context: Additional context to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Raises:     ValidationError: If the object could not be validated.   Returns:     The validated model instance. model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass !!! abstract "Usage Documentation"     [JSON Parsing](../concepts/json.md#json-parsing)   Validate the given JSON data against the Pydantic model.   Args:     json_data: The JSON data to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     context: Extra variables to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Returns:     The validated Pydantic model.   Raises:     ValidationError: If `json_data` is not a JSON string or the object could not be validated. model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Validate the given object with string data against the Pydantic model.   Args:     obj: The object containing string data to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     context: Extra variables to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Returns:     The validated Pydantic model. parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass parse_obj(obj: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]' from pydantic._internal._model_construction.ModelMetaclass schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str' from pydantic._internal._model_construction.ModelMetaclass update_forward_refs(**localns: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass validate(value: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Readonly properties inherited from pydantic.main.BaseModel: __fields_set__ model_extra Get extra fields set during validation.   Returns:     A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`. model_fields_set Returns the set of fields that have been explicitly set on this model instance.   Returns:     A set of strings representing the fields that have been set,         i.e. that were not filled from defaults. Data descriptors inherited from pydantic.main.BaseModel: __dict__ dictionary for instance variables (if defined) __pydantic_extra__ __pydantic_fields_set__ __pydantic_private__ Data and other attributes inherited from pydantic.main.BaseModel: __hash__ = None __pydantic_root_model__ = False model_computed_fields = {} model_fields = {'creation_timestamp': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'id': FieldInfo(annotation=str, required=True), 'is_version_head': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'managed_by': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'name': FieldInfo(annotation=str, required=True), 'scenario': FieldInfo(annotation=str, required=True), 'spec': FieldInfo(annotation=Union[PromptTemplateSpec, NoneType], required=False, default=None), 'version': FieldInfo(annotation=str, required=True)}   class PromptTemplateListResponse(pydantic.main.BaseModel)     PromptTemplateListResponse(*, count: int, resources: List[gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateGetResponse]) -&gt; None   Represents a response to a request to list prompt templates.   Args:     count: The number of prompt templates.       resources: The list of PromptGetResponse objects.     Method resolution order: PromptTemplateListResponse pydantic.main.BaseModel builtins.object Data descriptors defined here: __weakref__ list of weak references to the object (if defined) Data and other attributes defined here: __abstractmethods__ = frozenset() __annotations__ = {'count': <class 'int'>, 'resources': typing.List[gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateGetResponse]} __class_vars__ = set() __private_attributes__ = {} __pydantic_complete__ = True __pydantic_computed_fields__ = {} __pydantic_core_schema__ = {'cls': <class 'gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateListResponse'>, 'config': {'title': 'PromptTemplateListResponse'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...els.prompt_template.PromptTemplateListResponse'>>]}, 'ref': 'gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateListResponse:140540950954064', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'count': {'metadata': {}, 'schema': {'type': 'int'}, 'type': 'model-field'}, 'resources': {'metadata': {}, 'schema': {'items_schema': {'cls': <class 'gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateGetResponse'>, 'config': {...}, 'custom_init': False, 'metadata': {...}, 'ref': 'gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateGetResponse:140540951193152', 'root_model': False, 'schema': {...}, 'type': 'model'}, 'type': 'list'}, 'type': 'model-field'}}, 'model_name': 'PromptTemplateListResponse', 'type': 'model-fields'}, 'type': 'model'} __pydantic_custom_init__ = False __pydantic_decorators__ = DecoratorInfos(validators={}, field_validators={...zers={}, model_validators={}, computed_fields={}) __pydantic_extra_info__ = None __pydantic_fields__ = {'count': FieldInfo(annotation=int, required=True), 'resources': FieldInfo(annotation=List[PromptTemplateGetResponse], required=True)} __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'parameters': ()} __pydantic_parent_namespace__ = None __pydantic_post_init__ = None __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTrampoli...led_from_config: false, }, ), definitions=[]) __pydantic_setattr_handlers__ = {} __pydantic_validator__ = SchemaValidator(title="PromptTemplateListRespons...e", }, ), definitions=[], cache_strings=True) __signature__ = <Signature (*, count: int, resources: List[gen_a...mpt_template.PromptTemplateGetResponse]) -> None> model_config = {} Methods inherited from pydantic.main.BaseModel: __copy__(self) -> 'Self' Returns a shallow copy of the model. __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self' Returns a deep copy of the model. __delattr__(self, item: 'str') -> 'Any' Implement delattr(self, name). __eq__(self, other: 'Any') -> 'bool' Return self==value. __getattr__(self, item: 'str') -> 'Any' __getstate__(self) -> 'dict[Any, Any]' __init__(self, /, **data: 'Any') -> 'None' Create a new model by parsing and validating input data from keyword arguments.   Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.   `self` is explicitly positional-only to allow `self` as a field name. __iter__(self) -> 'TupleGenerator' So `dict(model)` works. __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects. __replace__(self, **changes: 'Any') -> 'Self' # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block: __repr__(self) -> 'str' Return repr(self). __repr_args__(self) -> '_repr.ReprArgs' __repr_name__(self) -> 'str' Name of the instance's class, used in __repr__. __repr_recursion__(self, object: 'Any') -> 'str' Returns the string representation of a recursive object. __repr_str__(self, join_str: 'str') -> 'str' __rich_repr__(self) -> 'RichReprResult' Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects. __setattr__(self, name: 'str', value: 'Any') -> 'None' Implement setattr(self, name, value). __setstate__(self, state: 'dict[Any, Any]') -> 'None' __str__(self) -> 'str' Return str(self). copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self' Returns a copy of the model.   !!! warning "Deprecated"     This method is now deprecated; use `model_copy` instead.   If you need `include` or `exclude`, use:   ```python {test="skip" lint="skip"} data = self.model_dump(include=include, exclude=exclude, round_trip=True) data = {**data, **(update or {})} copied = self.model_validate(data) ```   Args:     include: Optional set or mapping specifying which fields to include in the copied model.     exclude: Optional set or mapping specifying which fields to exclude in the copied model.     update: Optional dictionary of field-value pairs to override field values in the copied model.     deep: If True, the values of fields that are Pydantic models will be deep-copied.   Returns:     A copy of the model with included, excluded and updated fields as specified. dict(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False) -> 'Dict[str, Any]' json(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str' model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self' !!! abstract "Usage Documentation"     [`model_copy`](../concepts/models.md#model-copy)   Returns a copy of the model.   !!! note     The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This     might have unexpected side effects if you store anything in it, on top of the model     fields (e.g. the value of [cached properties][functools.cached_property]).   Args:     update: Values to change/add in the new model. Note: the data is not validated         before creating the new model. You should trust this data.     deep: Set to `True` to make a deep copy of the model.   Returns:     New model instance. model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]' !!! abstract "Usage Documentation"     [`model_dump`](../concepts/serialization.md#python-mode)   Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.   Args:     mode: The mode in which `to_python` should run.         If mode is 'json', the output will only contain JSON serializable types.         If mode is 'python', the output may contain non-JSON-serializable Python objects.     include: A set of fields to include in the output.     exclude: A set of fields to exclude from the output.     context: Additional context to pass to the serializer.     by_alias: Whether to use the field's alias in the dictionary key if defined.     exclude_unset: Whether to exclude fields that have not been explicitly set.     exclude_defaults: Whether to exclude fields that are set to their default value.     exclude_none: Whether to exclude fields that have a value of `None`.     exclude_computed_fields: Whether to exclude computed fields.         While this can be useful for round-tripping, it is usually recommended to use the dedicated         `round_trip` parameter instead.     round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].     warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,         "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].     fallback: A function to call when an unknown value is encountered. If not provided,         a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.     serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.     polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.   Returns:     A dictionary representation of the model. model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str' !!! abstract "Usage Documentation"     [`model_dump_json`](../concepts/serialization.md#json-mode)   Generates a JSON representation of the model using Pydantic's `to_json` method.   Args:     indent: Indentation to use in the JSON output. If None is passed, the output will be compact.     ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.         If `False` (the default), these characters will be output as-is.     include: Field(s) to include in the JSON output.     exclude: Field(s) to exclude from the JSON output.     context: Additional context to pass to the serializer.     by_alias: Whether to serialize using field aliases.     exclude_unset: Whether to exclude fields that have not been explicitly set.     exclude_defaults: Whether to exclude fields that are set to their default value.     exclude_none: Whether to exclude fields that have a value of `None`.     exclude_computed_fields: Whether to exclude computed fields.         While this can be useful for round-tripping, it is usually recommended to use the dedicated         `round_trip` parameter instead.     round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].     warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,         "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].     fallback: A function to call when an unknown value is encountered. If not provided,         a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.     serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.     polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.   Returns:     A JSON string representation of the model. model_post_init(self, context: 'Any', /) -> 'None' Override this method to perform additional initialization after `__init__` and `model_construct`. This is useful if you want to do some validation that requires the entire model to be initialized. Class methods inherited from pydantic.main.BaseModel: __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef' from pydantic._internal._model_construction.ModelMetaclass __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema' from pydantic._internal._model_construction.ModelMetaclass __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue' from pydantic._internal._model_construction.ModelMetaclass Hook into generating the model's JSON schema.   Args:     core_schema: A `pydantic-core` CoreSchema.         You can ignore this argument and call the handler with a new CoreSchema,         wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),         or just call the handler with the original schema.     handler: Call into Pydantic's internal JSON schema generation.         This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema         generation fails.         Since this gets called by `BaseModel.model_json_schema` you can override the         `schema_generator` argument to that function to change JSON schema generation globally         for a type.   Returns:     A JSON schema, as a Python object. __pydantic_init_subclass__(**kwargs: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass` only after basic class initialization is complete. In particular, attributes like `model_fields` will be present when this is called, but forward annotations are not guaranteed to be resolved yet, meaning that creating an instance of the class may fail.   This is necessary because `__init_subclass__` will always be called by `type.__new__`, and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that `type.__new__` was called in such a manner that the class would already be sufficiently initialized.   This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely, any kwargs passed to the class definition that aren't used internally by Pydantic.   Args:     **kwargs: Any keyword arguments passed to the class definition that aren't used internally         by Pydantic.   Note:     You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]     instead, which is called once the class and its fields are fully initialized and ready for validation. __pydantic_on_complete__() -> 'None' from pydantic._internal._model_construction.ModelMetaclass This is called once the class and its fields are fully initialized and ready to be used.   This typically happens when the class is created (just before [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass), except when forward annotations are used that could not immediately be resolved. In that case, it will be called later, when the model is rebuilt automatically or explicitly using [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild]. construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass from_orm(obj: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Creates a new instance of the `Model` class with validated data.   Creates a new model setting `__dict__` and `__pydantic_fields_set__` from trusted or pre-validated data. Default values are respected, but no other validation is performed.   !!! note     `model_construct()` generally respects the `model_config.extra` setting on the provided model.     That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`     and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.     Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in     an error if extra values are passed, but they will be ignored.   Args:     _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,         this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.         Otherwise, the field names from the `values` argument will be used.     values: Trusted or pre-validated data dictionary.   Returns:     A new instance of the `Model` class with validated data. model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]' from pydantic._internal._model_construction.ModelMetaclass Generates a JSON schema for a model class.   Args:     by_alias: Whether to use attribute aliases or not.     ref_template: The reference template.     union_format: The format to use when combining schemas from unions together. Can be one of:           - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)         keyword to combine schemas (the default).         - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)         keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive         type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to         `any_of`.     schema_generator: To override the logic used to generate the JSON schema, as a subclass of         `GenerateJsonSchema` with your desired modifications     mode: The mode in which to generate the schema.   Returns:     The JSON schema for the given model class. model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str' from pydantic._internal._model_construction.ModelMetaclass Compute the class name for parametrizations of generic classes.   This method can be overridden to achieve a custom naming scheme for generic BaseModels.   Args:     params: Tuple of types of the class. Given a generic class         `Model` with 2 type variables and a concrete model `Model[str, int]`,         the value `(str, int)` would be passed to `params`.   Returns:     String representing the new class where `params` are passed to `cls` as type variables.   Raises:     TypeError: Raised when trying to generate concrete names for non-generic models. model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None' from pydantic._internal._model_construction.ModelMetaclass Try to rebuild the pydantic-core schema for the model.   This may be necessary when one of the annotations is a ForwardRef which could not be resolved during the initial attempt to build the schema, and automatic rebuilding fails.   Args:     force: Whether to force the rebuilding of the model schema, defaults to `False`.     raise_errors: Whether to raise errors, defaults to `True`.     _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.     _types_namespace: The types namespace, defaults to `None`.   Returns:     Returns `None` if the schema is already "complete" and rebuilding was not required.     If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`. model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Validate a pydantic model instance.   Args:     obj: The object to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     from_attributes: Whether to extract data from object attributes.     context: Additional context to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Raises:     ValidationError: If the object could not be validated.   Returns:     The validated model instance. model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass !!! abstract "Usage Documentation"     [JSON Parsing](../concepts/json.md#json-parsing)   Validate the given JSON data against the Pydantic model.   Args:     json_data: The JSON data to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     context: Extra variables to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Returns:     The validated Pydantic model.   Raises:     ValidationError: If `json_data` is not a JSON string or the object could not be validated. model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Validate the given object with string data against the Pydantic model.   Args:     obj: The object containing string data to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     context: Extra variables to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Returns:     The validated Pydantic model. parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass parse_obj(obj: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]' from pydantic._internal._model_construction.ModelMetaclass schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str' from pydantic._internal._model_construction.ModelMetaclass update_forward_refs(**localns: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass validate(value: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Readonly properties inherited from pydantic.main.BaseModel: __fields_set__ model_extra Get extra fields set during validation.   Returns:     A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`. model_fields_set Returns the set of fields that have been explicitly set on this model instance.   Returns:     A set of strings representing the fields that have been set,         i.e. that were not filled from defaults. Data descriptors inherited from pydantic.main.BaseModel: __dict__ dictionary for instance variables (if defined) __pydantic_extra__ __pydantic_fields_set__ __pydantic_private__ Data and other attributes inherited from pydantic.main.BaseModel: __hash__ = None __pydantic_root_model__ = False model_computed_fields = {} model_fields = {'count': FieldInfo(annotation=int, required=True), 'resources': FieldInfo(annotation=List[PromptTemplateGetResponse], required=True)}   class PromptTemplatePostRequest(pydantic.main.BaseModel)     PromptTemplatePostRequest(*, name: str, version: str, scenario: str, spec: gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateSpec) -&gt; None   Represents a request to create a prompt template.   Args:     name: The name of the prompt template.       version: The version of the prompt template.       scenario: The scenario of the prompt template.       spec: The specification of the prompt template.     Method resolution order: PromptTemplatePostRequest pydantic.main.BaseModel builtins.object Data descriptors defined here: __weakref__ list of weak references to the object (if defined) Data and other attributes defined here: __abstractmethods__ = frozenset() __annotations__ = {'name': <class 'str'>, 'scenario': <class 'str'>, 'spec': <class 'gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateSpec'>, 'version': <class 'str'>} __class_vars__ = set() __private_attributes__ = {} __pydantic_complete__ = True __pydantic_computed_fields__ = {} __pydantic_core_schema__ = {'cls': <class 'gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplatePostRequest'>, 'config': {'title': 'PromptTemplatePostRequest'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...dels.prompt_template.PromptTemplatePostRequest'>>]}, 'ref': 'gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplatePostRequest:140540951191184', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'name': {'metadata': {}, 'schema': {'type': 'str'}, 'type': 'model-field'}, 'scenario': {'metadata': {}, 'schema': {'type': 'str'}, 'type': 'model-field'}, 'spec': {'metadata': {}, 'schema': {'cls': <class 'gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateSpec'>, 'config': {'title': 'PromptTemplateSpec'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [...]}, 'ref': 'gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateSpec:140540954130352', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {...}, 'model_name': 'PromptTemplateSpec', 'type': 'model-fields'}, 'type': 'model'}, 'type': 'model-field'}, 'version': {'metadata': {}, 'schema': {'type': 'str'}, 'type': 'model-field'}}, 'model_name': 'PromptTemplatePostRequest', 'type': 'model-fields'}, 'type': 'model'} __pydantic_custom_init__ = False __pydantic_decorators__ = DecoratorInfos(validators={}, field_validators={...zers={}, model_validators={}, computed_fields={}) __pydantic_extra_info__ = None __pydantic_fields__ = {'name': FieldInfo(annotation=str, required=True), 'scenario': FieldInfo(annotation=str, required=True), 'spec': FieldInfo(annotation=PromptTemplateSpec, required=True), 'version': FieldInfo(annotation=str, required=True)} __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'parameters': ()} __pydantic_parent_namespace__ = None __pydantic_post_init__ = None __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTrampoli...led_from_config: false, }, ), definitions=[]) __pydantic_setattr_handlers__ = {} __pydantic_validator__ = SchemaValidator(title="PromptTemplatePostRequest...t", }, ), definitions=[], cache_strings=True) __signature__ = <Signature (*, name: str, version: str, scenario...dels.prompt_template.PromptTemplateSpec) -> None> model_config = {} Methods inherited from pydantic.main.BaseModel: __copy__(self) -> 'Self' Returns a shallow copy of the model. __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self' Returns a deep copy of the model. __delattr__(self, item: 'str') -> 'Any' Implement delattr(self, name). __eq__(self, other: 'Any') -> 'bool' Return self==value. __getattr__(self, item: 'str') -> 'Any' __getstate__(self) -> 'dict[Any, Any]' __init__(self, /, **data: 'Any') -> 'None' Create a new model by parsing and validating input data from keyword arguments.   Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.   `self` is explicitly positional-only to allow `self` as a field name. __iter__(self) -> 'TupleGenerator' So `dict(model)` works. __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects. __replace__(self, **changes: 'Any') -> 'Self' # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block: __repr__(self) -> 'str' Return repr(self). __repr_args__(self) -> '_repr.ReprArgs' __repr_name__(self) -> 'str' Name of the instance's class, used in __repr__. __repr_recursion__(self, object: 'Any') -> 'str' Returns the string representation of a recursive object. __repr_str__(self, join_str: 'str') -> 'str' __rich_repr__(self) -> 'RichReprResult' Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects. __setattr__(self, name: 'str', value: 'Any') -> 'None' Implement setattr(self, name, value). __setstate__(self, state: 'dict[Any, Any]') -> 'None' __str__(self) -> 'str' Return str(self). copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self' Returns a copy of the model.   !!! warning "Deprecated"     This method is now deprecated; use `model_copy` instead.   If you need `include` or `exclude`, use:   ```python {test="skip" lint="skip"} data = self.model_dump(include=include, exclude=exclude, round_trip=True) data = {**data, **(update or {})} copied = self.model_validate(data) ```   Args:     include: Optional set or mapping specifying which fields to include in the copied model.     exclude: Optional set or mapping specifying which fields to exclude in the copied model.     update: Optional dictionary of field-value pairs to override field values in the copied model.     deep: If True, the values of fields that are Pydantic models will be deep-copied.   Returns:     A copy of the model with included, excluded and updated fields as specified. dict(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False) -> 'Dict[str, Any]' json(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str' model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self' !!! abstract "Usage Documentation"     [`model_copy`](../concepts/models.md#model-copy)   Returns a copy of the model.   !!! note     The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This     might have unexpected side effects if you store anything in it, on top of the model     fields (e.g. the value of [cached properties][functools.cached_property]).   Args:     update: Values to change/add in the new model. Note: the data is not validated         before creating the new model. You should trust this data.     deep: Set to `True` to make a deep copy of the model.   Returns:     New model instance. model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]' !!! abstract "Usage Documentation"     [`model_dump`](../concepts/serialization.md#python-mode)   Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.   Args:     mode: The mode in which `to_python` should run.         If mode is 'json', the output will only contain JSON serializable types.         If mode is 'python', the output may contain non-JSON-serializable Python objects.     include: A set of fields to include in the output.     exclude: A set of fields to exclude from the output.     context: Additional context to pass to the serializer.     by_alias: Whether to use the field's alias in the dictionary key if defined.     exclude_unset: Whether to exclude fields that have not been explicitly set.     exclude_defaults: Whether to exclude fields that are set to their default value.     exclude_none: Whether to exclude fields that have a value of `None`.     exclude_computed_fields: Whether to exclude computed fields.         While this can be useful for round-tripping, it is usually recommended to use the dedicated         `round_trip` parameter instead.     round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].     warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,         "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].     fallback: A function to call when an unknown value is encountered. If not provided,         a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.     serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.     polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.   Returns:     A dictionary representation of the model. model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str' !!! abstract "Usage Documentation"     [`model_dump_json`](../concepts/serialization.md#json-mode)   Generates a JSON representation of the model using Pydantic's `to_json` method.   Args:     indent: Indentation to use in the JSON output. If None is passed, the output will be compact.     ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.         If `False` (the default), these characters will be output as-is.     include: Field(s) to include in the JSON output.     exclude: Field(s) to exclude from the JSON output.     context: Additional context to pass to the serializer.     by_alias: Whether to serialize using field aliases.     exclude_unset: Whether to exclude fields that have not been explicitly set.     exclude_defaults: Whether to exclude fields that are set to their default value.     exclude_none: Whether to exclude fields that have a value of `None`.     exclude_computed_fields: Whether to exclude computed fields.         While this can be useful for round-tripping, it is usually recommended to use the dedicated         `round_trip` parameter instead.     round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].     warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,         "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].     fallback: A function to call when an unknown value is encountered. If not provided,         a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.     serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.     polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.   Returns:     A JSON string representation of the model. model_post_init(self, context: 'Any', /) -> 'None' Override this method to perform additional initialization after `__init__` and `model_construct`. This is useful if you want to do some validation that requires the entire model to be initialized. Class methods inherited from pydantic.main.BaseModel: __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef' from pydantic._internal._model_construction.ModelMetaclass __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema' from pydantic._internal._model_construction.ModelMetaclass __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue' from pydantic._internal._model_construction.ModelMetaclass Hook into generating the model's JSON schema.   Args:     core_schema: A `pydantic-core` CoreSchema.         You can ignore this argument and call the handler with a new CoreSchema,         wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),         or just call the handler with the original schema.     handler: Call into Pydantic's internal JSON schema generation.         This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema         generation fails.         Since this gets called by `BaseModel.model_json_schema` you can override the         `schema_generator` argument to that function to change JSON schema generation globally         for a type.   Returns:     A JSON schema, as a Python object. __pydantic_init_subclass__(**kwargs: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass` only after basic class initialization is complete. In particular, attributes like `model_fields` will be present when this is called, but forward annotations are not guaranteed to be resolved yet, meaning that creating an instance of the class may fail.   This is necessary because `__init_subclass__` will always be called by `type.__new__`, and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that `type.__new__` was called in such a manner that the class would already be sufficiently initialized.   This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely, any kwargs passed to the class definition that aren't used internally by Pydantic.   Args:     **kwargs: Any keyword arguments passed to the class definition that aren't used internally         by Pydantic.   Note:     You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]     instead, which is called once the class and its fields are fully initialized and ready for validation. __pydantic_on_complete__() -> 'None' from pydantic._internal._model_construction.ModelMetaclass This is called once the class and its fields are fully initialized and ready to be used.   This typically happens when the class is created (just before [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass), except when forward annotations are used that could not immediately be resolved. In that case, it will be called later, when the model is rebuilt automatically or explicitly using [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild]. construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass from_orm(obj: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Creates a new instance of the `Model` class with validated data.   Creates a new model setting `__dict__` and `__pydantic_fields_set__` from trusted or pre-validated data. Default values are respected, but no other validation is performed.   !!! note     `model_construct()` generally respects the `model_config.extra` setting on the provided model.     That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`     and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.     Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in     an error if extra values are passed, but they will be ignored.   Args:     _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,         this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.         Otherwise, the field names from the `values` argument will be used.     values: Trusted or pre-validated data dictionary.   Returns:     A new instance of the `Model` class with validated data. model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]' from pydantic._internal._model_construction.ModelMetaclass Generates a JSON schema for a model class.   Args:     by_alias: Whether to use attribute aliases or not.     ref_template: The reference template.     union_format: The format to use when combining schemas from unions together. Can be one of:           - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)         keyword to combine schemas (the default).         - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)         keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive         type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to         `any_of`.     schema_generator: To override the logic used to generate the JSON schema, as a subclass of         `GenerateJsonSchema` with your desired modifications     mode: The mode in which to generate the schema.   Returns:     The JSON schema for the given model class. model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str' from pydantic._internal._model_construction.ModelMetaclass Compute the class name for parametrizations of generic classes.   This method can be overridden to achieve a custom naming scheme for generic BaseModels.   Args:     params: Tuple of types of the class. Given a generic class         `Model` with 2 type variables and a concrete model `Model[str, int]`,         the value `(str, int)` would be passed to `params`.   Returns:     String representing the new class where `params` are passed to `cls` as type variables.   Raises:     TypeError: Raised when trying to generate concrete names for non-generic models. model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None' from pydantic._internal._model_construction.ModelMetaclass Try to rebuild the pydantic-core schema for the model.   This may be necessary when one of the annotations is a ForwardRef which could not be resolved during the initial attempt to build the schema, and automatic rebuilding fails.   Args:     force: Whether to force the rebuilding of the model schema, defaults to `False`.     raise_errors: Whether to raise errors, defaults to `True`.     _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.     _types_namespace: The types namespace, defaults to `None`.   Returns:     Returns `None` if the schema is already "complete" and rebuilding was not required.     If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`. model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Validate a pydantic model instance.   Args:     obj: The object to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     from_attributes: Whether to extract data from object attributes.     context: Additional context to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Raises:     ValidationError: If the object could not be validated.   Returns:     The validated model instance. model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass !!! abstract "Usage Documentation"     [JSON Parsing](../concepts/json.md#json-parsing)   Validate the given JSON data against the Pydantic model.   Args:     json_data: The JSON data to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     context: Extra variables to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Returns:     The validated Pydantic model.   Raises:     ValidationError: If `json_data` is not a JSON string or the object could not be validated. model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Validate the given object with string data against the Pydantic model.   Args:     obj: The object containing string data to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     context: Extra variables to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Returns:     The validated Pydantic model. parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass parse_obj(obj: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]' from pydantic._internal._model_construction.ModelMetaclass schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str' from pydantic._internal._model_construction.ModelMetaclass update_forward_refs(**localns: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass validate(value: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Readonly properties inherited from pydantic.main.BaseModel: __fields_set__ model_extra Get extra fields set during validation.   Returns:     A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`. model_fields_set Returns the set of fields that have been explicitly set on this model instance.   Returns:     A set of strings representing the fields that have been set,         i.e. that were not filled from defaults. Data descriptors inherited from pydantic.main.BaseModel: __dict__ dictionary for instance variables (if defined) __pydantic_extra__ __pydantic_fields_set__ __pydantic_private__ Data and other attributes inherited from pydantic.main.BaseModel: __hash__ = None __pydantic_root_model__ = False model_computed_fields = {} model_fields = {'name': FieldInfo(annotation=str, required=True), 'scenario': FieldInfo(annotation=str, required=True), 'spec': FieldInfo(annotation=PromptTemplateSpec, required=True), 'version': FieldInfo(annotation=str, required=True)}   class PromptTemplatePostResponse(pydantic.main.BaseModel)     PromptTemplatePostResponse(*, message: str, id: str, scenario: str, name: str, version: str) -&gt; None   Represents a response to a request to create a prompt template.   Args:     message: The message of the response.       id: The ID of the prompt template.       scenario: The scenario of the prompt template.       name: The name of the prompt template.       version: The version of the prompt template.     Method resolution order: PromptTemplatePostResponse pydantic.main.BaseModel builtins.object Data descriptors defined here: __weakref__ list of weak references to the object (if defined) Data and other attributes defined here: __abstractmethods__ = frozenset() __annotations__ = {'id': <class 'str'>, 'message': <class 'str'>, 'name': <class 'str'>, 'scenario': <class 'str'>, 'version': <class 'str'>} __class_vars__ = set() __private_attributes__ = {} __pydantic_complete__ = True __pydantic_computed_fields__ = {} __pydantic_core_schema__ = {'cls': <class 'gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplatePostResponse'>, 'config': {'title': 'PromptTemplatePostResponse'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...els.prompt_template.PromptTemplatePostResponse'>>]}, 'ref': 'gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplatePostResponse:140540951192192', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'id': {'metadata': {}, 'schema': {'type': 'str'}, 'type': 'model-field'}, 'message': {'metadata': {}, 'schema': {'type': 'str'}, 'type': 'model-field'}, 'name': {'metadata': {}, 'schema': {'type': 'str'}, 'type': 'model-field'}, 'scenario': {'metadata': {}, 'schema': {'type': 'str'}, 'type': 'model-field'}, 'version': {'metadata': {}, 'schema': {'type': 'str'}, 'type': 'model-field'}}, 'model_name': 'PromptTemplatePostResponse', 'type': 'model-fields'}, 'type': 'model'} __pydantic_custom_init__ = False __pydantic_decorators__ = DecoratorInfos(validators={}, field_validators={...zers={}, model_validators={}, computed_fields={}) __pydantic_extra_info__ = None __pydantic_fields__ = {'id': FieldInfo(annotation=str, required=True), 'message': FieldInfo(annotation=str, required=True), 'name': FieldInfo(annotation=str, required=True), 'scenario': FieldInfo(annotation=str, required=True), 'version': FieldInfo(annotation=str, required=True)} __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'parameters': ()} __pydantic_parent_namespace__ = None __pydantic_post_init__ = None __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTrampoli...led_from_config: false, }, ), definitions=[]) __pydantic_setattr_handlers__ = {} __pydantic_validator__ = SchemaValidator(title="PromptTemplatePostRespons...e", }, ), definitions=[], cache_strings=True) __signature__ = <Signature (*, message: str, id: str, scenario: str, name: str, version: str) -> None> model_config = {} Methods inherited from pydantic.main.BaseModel: __copy__(self) -> 'Self' Returns a shallow copy of the model. __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self' Returns a deep copy of the model. __delattr__(self, item: 'str') -> 'Any' Implement delattr(self, name). __eq__(self, other: 'Any') -> 'bool' Return self==value. __getattr__(self, item: 'str') -> 'Any' __getstate__(self) -> 'dict[Any, Any]' __init__(self, /, **data: 'Any') -> 'None' Create a new model by parsing and validating input data from keyword arguments.   Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.   `self` is explicitly positional-only to allow `self` as a field name. __iter__(self) -> 'TupleGenerator' So `dict(model)` works. __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects. __replace__(self, **changes: 'Any') -> 'Self' # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block: __repr__(self) -> 'str' Return repr(self). __repr_args__(self) -> '_repr.ReprArgs' __repr_name__(self) -> 'str' Name of the instance's class, used in __repr__. __repr_recursion__(self, object: 'Any') -> 'str' Returns the string representation of a recursive object. __repr_str__(self, join_str: 'str') -> 'str' __rich_repr__(self) -> 'RichReprResult' Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects. __setattr__(self, name: 'str', value: 'Any') -> 'None' Implement setattr(self, name, value). __setstate__(self, state: 'dict[Any, Any]') -> 'None' __str__(self) -> 'str' Return str(self). copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self' Returns a copy of the model.   !!! warning "Deprecated"     This method is now deprecated; use `model_copy` instead.   If you need `include` or `exclude`, use:   ```python {test="skip" lint="skip"} data = self.model_dump(include=include, exclude=exclude, round_trip=True) data = {**data, **(update or {})} copied = self.model_validate(data) ```   Args:     include: Optional set or mapping specifying which fields to include in the copied model.     exclude: Optional set or mapping specifying which fields to exclude in the copied model.     update: Optional dictionary of field-value pairs to override field values in the copied model.     deep: If True, the values of fields that are Pydantic models will be deep-copied.   Returns:     A copy of the model with included, excluded and updated fields as specified. dict(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False) -> 'Dict[str, Any]' json(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str' model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self' !!! abstract "Usage Documentation"     [`model_copy`](../concepts/models.md#model-copy)   Returns a copy of the model.   !!! note     The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This     might have unexpected side effects if you store anything in it, on top of the model     fields (e.g. the value of [cached properties][functools.cached_property]).   Args:     update: Values to change/add in the new model. Note: the data is not validated         before creating the new model. You should trust this data.     deep: Set to `True` to make a deep copy of the model.   Returns:     New model instance. model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]' !!! abstract "Usage Documentation"     [`model_dump`](../concepts/serialization.md#python-mode)   Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.   Args:     mode: The mode in which `to_python` should run.         If mode is 'json', the output will only contain JSON serializable types.         If mode is 'python', the output may contain non-JSON-serializable Python objects.     include: A set of fields to include in the output.     exclude: A set of fields to exclude from the output.     context: Additional context to pass to the serializer.     by_alias: Whether to use the field's alias in the dictionary key if defined.     exclude_unset: Whether to exclude fields that have not been explicitly set.     exclude_defaults: Whether to exclude fields that are set to their default value.     exclude_none: Whether to exclude fields that have a value of `None`.     exclude_computed_fields: Whether to exclude computed fields.         While this can be useful for round-tripping, it is usually recommended to use the dedicated         `round_trip` parameter instead.     round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].     warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,         "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].     fallback: A function to call when an unknown value is encountered. If not provided,         a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.     serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.     polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.   Returns:     A dictionary representation of the model. model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str' !!! abstract "Usage Documentation"     [`model_dump_json`](../concepts/serialization.md#json-mode)   Generates a JSON representation of the model using Pydantic's `to_json` method.   Args:     indent: Indentation to use in the JSON output. If None is passed, the output will be compact.     ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.         If `False` (the default), these characters will be output as-is.     include: Field(s) to include in the JSON output.     exclude: Field(s) to exclude from the JSON output.     context: Additional context to pass to the serializer.     by_alias: Whether to serialize using field aliases.     exclude_unset: Whether to exclude fields that have not been explicitly set.     exclude_defaults: Whether to exclude fields that are set to their default value.     exclude_none: Whether to exclude fields that have a value of `None`.     exclude_computed_fields: Whether to exclude computed fields.         While this can be useful for round-tripping, it is usually recommended to use the dedicated         `round_trip` parameter instead.     round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].     warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,         "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].     fallback: A function to call when an unknown value is encountered. If not provided,         a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.     serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.     polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.   Returns:     A JSON string representation of the model. model_post_init(self, context: 'Any', /) -> 'None' Override this method to perform additional initialization after `__init__` and `model_construct`. This is useful if you want to do some validation that requires the entire model to be initialized. Class methods inherited from pydantic.main.BaseModel: __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef' from pydantic._internal._model_construction.ModelMetaclass __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema' from pydantic._internal._model_construction.ModelMetaclass __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue' from pydantic._internal._model_construction.ModelMetaclass Hook into generating the model's JSON schema.   Args:     core_schema: A `pydantic-core` CoreSchema.         You can ignore this argument and call the handler with a new CoreSchema,         wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),         or just call the handler with the original schema.     handler: Call into Pydantic's internal JSON schema generation.         This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema         generation fails.         Since this gets called by `BaseModel.model_json_schema` you can override the         `schema_generator` argument to that function to change JSON schema generation globally         for a type.   Returns:     A JSON schema, as a Python object. __pydantic_init_subclass__(**kwargs: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass` only after basic class initialization is complete. In particular, attributes like `model_fields` will be present when this is called, but forward annotations are not guaranteed to be resolved yet, meaning that creating an instance of the class may fail.   This is necessary because `__init_subclass__` will always be called by `type.__new__`, and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that `type.__new__` was called in such a manner that the class would already be sufficiently initialized.   This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely, any kwargs passed to the class definition that aren't used internally by Pydantic.   Args:     **kwargs: Any keyword arguments passed to the class definition that aren't used internally         by Pydantic.   Note:     You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]     instead, which is called once the class and its fields are fully initialized and ready for validation. __pydantic_on_complete__() -> 'None' from pydantic._internal._model_construction.ModelMetaclass This is called once the class and its fields are fully initialized and ready to be used.   This typically happens when the class is created (just before [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass), except when forward annotations are used that could not immediately be resolved. In that case, it will be called later, when the model is rebuilt automatically or explicitly using [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild]. construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass from_orm(obj: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Creates a new instance of the `Model` class with validated data.   Creates a new model setting `__dict__` and `__pydantic_fields_set__` from trusted or pre-validated data. Default values are respected, but no other validation is performed.   !!! note     `model_construct()` generally respects the `model_config.extra` setting on the provided model.     That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`     and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.     Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in     an error if extra values are passed, but they will be ignored.   Args:     _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,         this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.         Otherwise, the field names from the `values` argument will be used.     values: Trusted or pre-validated data dictionary.   Returns:     A new instance of the `Model` class with validated data. model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]' from pydantic._internal._model_construction.ModelMetaclass Generates a JSON schema for a model class.   Args:     by_alias: Whether to use attribute aliases or not.     ref_template: The reference template.     union_format: The format to use when combining schemas from unions together. Can be one of:           - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)         keyword to combine schemas (the default).         - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)         keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive         type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to         `any_of`.     schema_generator: To override the logic used to generate the JSON schema, as a subclass of         `GenerateJsonSchema` with your desired modifications     mode: The mode in which to generate the schema.   Returns:     The JSON schema for the given model class. model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str' from pydantic._internal._model_construction.ModelMetaclass Compute the class name for parametrizations of generic classes.   This method can be overridden to achieve a custom naming scheme for generic BaseModels.   Args:     params: Tuple of types of the class. Given a generic class         `Model` with 2 type variables and a concrete model `Model[str, int]`,         the value `(str, int)` would be passed to `params`.   Returns:     String representing the new class where `params` are passed to `cls` as type variables.   Raises:     TypeError: Raised when trying to generate concrete names for non-generic models. model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None' from pydantic._internal._model_construction.ModelMetaclass Try to rebuild the pydantic-core schema for the model.   This may be necessary when one of the annotations is a ForwardRef which could not be resolved during the initial attempt to build the schema, and automatic rebuilding fails.   Args:     force: Whether to force the rebuilding of the model schema, defaults to `False`.     raise_errors: Whether to raise errors, defaults to `True`.     _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.     _types_namespace: The types namespace, defaults to `None`.   Returns:     Returns `None` if the schema is already "complete" and rebuilding was not required.     If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`. model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Validate a pydantic model instance.   Args:     obj: The object to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     from_attributes: Whether to extract data from object attributes.     context: Additional context to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Raises:     ValidationError: If the object could not be validated.   Returns:     The validated model instance. model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass !!! abstract "Usage Documentation"     [JSON Parsing](../concepts/json.md#json-parsing)   Validate the given JSON data against the Pydantic model.   Args:     json_data: The JSON data to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     context: Extra variables to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Returns:     The validated Pydantic model.   Raises:     ValidationError: If `json_data` is not a JSON string or the object could not be validated. model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Validate the given object with string data against the Pydantic model.   Args:     obj: The object containing string data to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     context: Extra variables to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Returns:     The validated Pydantic model. parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass parse_obj(obj: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]' from pydantic._internal._model_construction.ModelMetaclass schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str' from pydantic._internal._model_construction.ModelMetaclass update_forward_refs(**localns: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass validate(value: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Readonly properties inherited from pydantic.main.BaseModel: __fields_set__ model_extra Get extra fields set during validation.   Returns:     A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`. model_fields_set Returns the set of fields that have been explicitly set on this model instance.   Returns:     A set of strings representing the fields that have been set,         i.e. that were not filled from defaults. Data descriptors inherited from pydantic.main.BaseModel: __dict__ dictionary for instance variables (if defined) __pydantic_extra__ __pydantic_fields_set__ __pydantic_private__ Data and other attributes inherited from pydantic.main.BaseModel: __hash__ = None __pydantic_root_model__ = False model_computed_fields = {} model_fields = {'id': FieldInfo(annotation=str, required=True), 'message': FieldInfo(annotation=str, required=True), 'name': FieldInfo(annotation=str, required=True), 'scenario': FieldInfo(annotation=str, required=True), 'version': FieldInfo(annotation=str, required=True)}   class PromptTemplateSpec(pydantic.main.BaseModel)     PromptTemplateSpec(*, template: List[gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplate], defaults: Optional[dict] = None, response_format: Union[gen_ai_hub.orchestration_v2.models.response_format.ResponseFormatText, gen_ai_hub.orchestration_v2.models.response_format.ResponseFormatJsonObject, gen_ai_hub.orchestration_v2.models.response_format.ResponseFormatJsonSchema, NoneType] = None, tools: Optional[List[dict | gen_ai_hub.orchestration_v2.models.tools.FunctionTool]] = None, additional_fields: Optional[Dict[Any, Any]] = &lt;factory&gt;) -&gt; None   Represents a prompt template specification.   Args:     Args:     template: A list of prompt messages that form the template.       defaults: A dict of default values for template variables.       tools: A list of tool definitions.       response_format: A response format that the model output should adhere to.       additional_fields: Additional fields for the prompt template.     Method resolution order: PromptTemplateSpec pydantic.main.BaseModel builtins.object Data descriptors defined here: __weakref__ list of weak references to the object (if defined) Data and other attributes defined here: __abstractmethods__ = frozenset() __annotations__ = {'additional_fields': typing.Optional[typing.Dict[typing.Any, typing.Any]], 'defaults': typing.Optional[dict], 'response_format': typing.Union[gen_ai_hub.orchestration_v2.models....sponse_format.ResponseFormatJsonSchema, NoneType], 'template': typing.List[gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplate], 'tools': typing.Optional[typing.List[dict | gen_ai_hub.orchestration_v2.models.tools.FunctionTool]]} __class_vars__ = set() __private_attributes__ = {} __pydantic_complete__ = True __pydantic_computed_fields__ = {} __pydantic_core_schema__ = {'cls': <class 'gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateSpec'>, 'config': {'title': 'PromptTemplateSpec'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...stry.models.prompt_template.PromptTemplateSpec'>>]}, 'ref': 'gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateSpec:140540954130352', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'additional_fields': {'metadata': {}, 'schema': {'default_factory': <class 'dict'>, 'default_factory_takes_data': False, 'schema': {'schema': {...}, 'type': 'nullable'}, 'type': 'default'}, 'type': 'model-field'}, 'defaults': {'metadata': {}, 'schema': {'default': None, 'schema': {'schema': {...}, 'type': 'nullable'}, 'type': 'default'}, 'type': 'model-field'}, 'response_format': {'metadata': {}, 'schema': {'default': None, 'schema': {'schema': {...}, 'type': 'nullable'}, 'type': 'default'}, 'type': 'model-field'}, 'template': {'metadata': {}, 'schema': {'items_schema': {'cls': <class 'gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplate'>, 'config': {...}, 'custom_init': False, 'metadata': {...}, 'ref': 'gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplate:140540951190128', 'root_model': False, 'schema': {...}, 'type': 'model'}, 'type': 'list'}, 'type': 'model-field'}, 'tools': {'metadata': {}, 'schema': {'default': None, 'schema': {'schema': {...}, 'type': 'nullable'}, 'type': 'default'}, 'type': 'model-field'}}, 'model_name': 'PromptTemplateSpec', 'type': 'model-fields'}, 'type': 'model'} __pydantic_custom_init__ = False __pydantic_decorators__ = DecoratorInfos(validators={}, field_validators={...zers={}, model_validators={}, computed_fields={}) __pydantic_extra_info__ = None __pydantic_fields__ = {'additional_fields': FieldInfo(annotation=Union[Dict[Any, Any], NoneType], required=False, default_factory=dict), 'defaults': FieldInfo(annotation=Union[dict, NoneType], required=False, default=None), 'response_format': FieldInfo(annotation=Union[ResponseFormatText, R...nSchema, NoneType], required=False, default=None), 'template': FieldInfo(annotation=List[PromptTemplate], required=True), 'tools': FieldInfo(annotation=Union[List[Union[dict, FunctionTool]], NoneType], required=False, default=None)} __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'parameters': ()} __pydantic_parent_namespace__ = None __pydantic_post_init__ = None __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTrampoli...led_from_config: false, }, ), definitions=[]) __pydantic_setattr_handlers__ = {} __pydantic_validator__ = SchemaValidator(title="PromptTemplateSpec", vali...c", }, ), definitions=[], cache_strings=True) __signature__ = <Signature (*, template: List[gen_ai_hub.prompt_...s: Optional[Dict[Any, Any]] = <factory>) -> None> model_config = {} Methods inherited from pydantic.main.BaseModel: __copy__(self) -> 'Self' Returns a shallow copy of the model. __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self' Returns a deep copy of the model. __delattr__(self, item: 'str') -> 'Any' Implement delattr(self, name). __eq__(self, other: 'Any') -> 'bool' Return self==value. __getattr__(self, item: 'str') -> 'Any' __getstate__(self) -> 'dict[Any, Any]' __init__(self, /, **data: 'Any') -> 'None' Create a new model by parsing and validating input data from keyword arguments.   Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.   `self` is explicitly positional-only to allow `self` as a field name. __iter__(self) -> 'TupleGenerator' So `dict(model)` works. __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects. __replace__(self, **changes: 'Any') -> 'Self' # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block: __repr__(self) -> 'str' Return repr(self). __repr_args__(self) -> '_repr.ReprArgs' __repr_name__(self) -> 'str' Name of the instance's class, used in __repr__. __repr_recursion__(self, object: 'Any') -> 'str' Returns the string representation of a recursive object. __repr_str__(self, join_str: 'str') -> 'str' __rich_repr__(self) -> 'RichReprResult' Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects. __setattr__(self, name: 'str', value: 'Any') -> 'None' Implement setattr(self, name, value). __setstate__(self, state: 'dict[Any, Any]') -> 'None' __str__(self) -> 'str' Return str(self). copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self' Returns a copy of the model.   !!! warning "Deprecated"     This method is now deprecated; use `model_copy` instead.   If you need `include` or `exclude`, use:   ```python {test="skip" lint="skip"} data = self.model_dump(include=include, exclude=exclude, round_trip=True) data = {**data, **(update or {})} copied = self.model_validate(data) ```   Args:     include: Optional set or mapping specifying which fields to include in the copied model.     exclude: Optional set or mapping specifying which fields to exclude in the copied model.     update: Optional dictionary of field-value pairs to override field values in the copied model.     deep: If True, the values of fields that are Pydantic models will be deep-copied.   Returns:     A copy of the model with included, excluded and updated fields as specified. dict(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False) -> 'Dict[str, Any]' json(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str' model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self' !!! abstract "Usage Documentation"     [`model_copy`](../concepts/models.md#model-copy)   Returns a copy of the model.   !!! note     The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This     might have unexpected side effects if you store anything in it, on top of the model     fields (e.g. the value of [cached properties][functools.cached_property]).   Args:     update: Values to change/add in the new model. Note: the data is not validated         before creating the new model. You should trust this data.     deep: Set to `True` to make a deep copy of the model.   Returns:     New model instance. model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]' !!! abstract "Usage Documentation"     [`model_dump`](../concepts/serialization.md#python-mode)   Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.   Args:     mode: The mode in which `to_python` should run.         If mode is 'json', the output will only contain JSON serializable types.         If mode is 'python', the output may contain non-JSON-serializable Python objects.     include: A set of fields to include in the output.     exclude: A set of fields to exclude from the output.     context: Additional context to pass to the serializer.     by_alias: Whether to use the field's alias in the dictionary key if defined.     exclude_unset: Whether to exclude fields that have not been explicitly set.     exclude_defaults: Whether to exclude fields that are set to their default value.     exclude_none: Whether to exclude fields that have a value of `None`.     exclude_computed_fields: Whether to exclude computed fields.         While this can be useful for round-tripping, it is usually recommended to use the dedicated         `round_trip` parameter instead.     round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].     warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,         "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].     fallback: A function to call when an unknown value is encountered. If not provided,         a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.     serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.     polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.   Returns:     A dictionary representation of the model. model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str' !!! abstract "Usage Documentation"     [`model_dump_json`](../concepts/serialization.md#json-mode)   Generates a JSON representation of the model using Pydantic's `to_json` method.   Args:     indent: Indentation to use in the JSON output. If None is passed, the output will be compact.     ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.         If `False` (the default), these characters will be output as-is.     include: Field(s) to include in the JSON output.     exclude: Field(s) to exclude from the JSON output.     context: Additional context to pass to the serializer.     by_alias: Whether to serialize using field aliases.     exclude_unset: Whether to exclude fields that have not been explicitly set.     exclude_defaults: Whether to exclude fields that are set to their default value.     exclude_none: Whether to exclude fields that have a value of `None`.     exclude_computed_fields: Whether to exclude computed fields.         While this can be useful for round-tripping, it is usually recommended to use the dedicated         `round_trip` parameter instead.     round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].     warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,         "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].     fallback: A function to call when an unknown value is encountered. If not provided,         a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.     serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.     polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.   Returns:     A JSON string representation of the model. model_post_init(self, context: 'Any', /) -> 'None' Override this method to perform additional initialization after `__init__` and `model_construct`. This is useful if you want to do some validation that requires the entire model to be initialized. Class methods inherited from pydantic.main.BaseModel: __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef' from pydantic._internal._model_construction.ModelMetaclass __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema' from pydantic._internal._model_construction.ModelMetaclass __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue' from pydantic._internal._model_construction.ModelMetaclass Hook into generating the model's JSON schema.   Args:     core_schema: A `pydantic-core` CoreSchema.         You can ignore this argument and call the handler with a new CoreSchema,         wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),         or just call the handler with the original schema.     handler: Call into Pydantic's internal JSON schema generation.         This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema         generation fails.         Since this gets called by `BaseModel.model_json_schema` you can override the         `schema_generator` argument to that function to change JSON schema generation globally         for a type.   Returns:     A JSON schema, as a Python object. __pydantic_init_subclass__(**kwargs: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass` only after basic class initialization is complete. In particular, attributes like `model_fields` will be present when this is called, but forward annotations are not guaranteed to be resolved yet, meaning that creating an instance of the class may fail.   This is necessary because `__init_subclass__` will always be called by `type.__new__`, and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that `type.__new__` was called in such a manner that the class would already be sufficiently initialized.   This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely, any kwargs passed to the class definition that aren't used internally by Pydantic.   Args:     **kwargs: Any keyword arguments passed to the class definition that aren't used internally         by Pydantic.   Note:     You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]     instead, which is called once the class and its fields are fully initialized and ready for validation. __pydantic_on_complete__() -> 'None' from pydantic._internal._model_construction.ModelMetaclass This is called once the class and its fields are fully initialized and ready to be used.   This typically happens when the class is created (just before [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass), except when forward annotations are used that could not immediately be resolved. In that case, it will be called later, when the model is rebuilt automatically or explicitly using [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild]. construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass from_orm(obj: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Creates a new instance of the `Model` class with validated data.   Creates a new model setting `__dict__` and `__pydantic_fields_set__` from trusted or pre-validated data. Default values are respected, but no other validation is performed.   !!! note     `model_construct()` generally respects the `model_config.extra` setting on the provided model.     That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`     and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.     Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in     an error if extra values are passed, but they will be ignored.   Args:     _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,         this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.         Otherwise, the field names from the `values` argument will be used.     values: Trusted or pre-validated data dictionary.   Returns:     A new instance of the `Model` class with validated data. model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]' from pydantic._internal._model_construction.ModelMetaclass Generates a JSON schema for a model class.   Args:     by_alias: Whether to use attribute aliases or not.     ref_template: The reference template.     union_format: The format to use when combining schemas from unions together. Can be one of:           - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)         keyword to combine schemas (the default).         - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)         keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive         type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to         `any_of`.     schema_generator: To override the logic used to generate the JSON schema, as a subclass of         `GenerateJsonSchema` with your desired modifications     mode: The mode in which to generate the schema.   Returns:     The JSON schema for the given model class. model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str' from pydantic._internal._model_construction.ModelMetaclass Compute the class name for parametrizations of generic classes.   This method can be overridden to achieve a custom naming scheme for generic BaseModels.   Args:     params: Tuple of types of the class. Given a generic class         `Model` with 2 type variables and a concrete model `Model[str, int]`,         the value `(str, int)` would be passed to `params`.   Returns:     String representing the new class where `params` are passed to `cls` as type variables.   Raises:     TypeError: Raised when trying to generate concrete names for non-generic models. model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None' from pydantic._internal._model_construction.ModelMetaclass Try to rebuild the pydantic-core schema for the model.   This may be necessary when one of the annotations is a ForwardRef which could not be resolved during the initial attempt to build the schema, and automatic rebuilding fails.   Args:     force: Whether to force the rebuilding of the model schema, defaults to `False`.     raise_errors: Whether to raise errors, defaults to `True`.     _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.     _types_namespace: The types namespace, defaults to `None`.   Returns:     Returns `None` if the schema is already "complete" and rebuilding was not required.     If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`. model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Validate a pydantic model instance.   Args:     obj: The object to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     from_attributes: Whether to extract data from object attributes.     context: Additional context to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Raises:     ValidationError: If the object could not be validated.   Returns:     The validated model instance. model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass !!! abstract "Usage Documentation"     [JSON Parsing](../concepts/json.md#json-parsing)   Validate the given JSON data against the Pydantic model.   Args:     json_data: The JSON data to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     context: Extra variables to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Returns:     The validated Pydantic model.   Raises:     ValidationError: If `json_data` is not a JSON string or the object could not be validated. model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Validate the given object with string data against the Pydantic model.   Args:     obj: The object containing string data to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     context: Extra variables to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Returns:     The validated Pydantic model. parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass parse_obj(obj: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]' from pydantic._internal._model_construction.ModelMetaclass schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str' from pydantic._internal._model_construction.ModelMetaclass update_forward_refs(**localns: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass validate(value: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Readonly properties inherited from pydantic.main.BaseModel: __fields_set__ model_extra Get extra fields set during validation.   Returns:     A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`. model_fields_set Returns the set of fields that have been explicitly set on this model instance.   Returns:     A set of strings representing the fields that have been set,         i.e. that were not filled from defaults. Data descriptors inherited from pydantic.main.BaseModel: __dict__ dictionary for instance variables (if defined) __pydantic_extra__ __pydantic_fields_set__ __pydantic_private__ Data and other attributes inherited from pydantic.main.BaseModel: __hash__ = None __pydantic_root_model__ = False model_computed_fields = {} model_fields = {'additional_fields': FieldInfo(annotation=Union[Dict[Any, Any], NoneType], required=False, default_factory=dict), 'defaults': FieldInfo(annotation=Union[dict, NoneType], required=False, default=None), 'response_format': FieldInfo(annotation=Union[ResponseFormatText, R...nSchema, NoneType], required=False, default=None), 'template': FieldInfo(annotation=List[PromptTemplate], required=True), 'tools': FieldInfo(annotation=Union[List[Union[dict, FunctionTool]], NoneType], required=False, default=None)}   class PromptTemplateSubstitutionRequest(pydantic.main.BaseModel)     PromptTemplateSubstitutionRequest(*, inputParams: Optional[Dict[Any, Any]] = &lt;factory&gt;) -&gt; None   Represents a request to substitute a prompt template.   Args:     input_params: User provided values to replace the placeholders of the prompt template.     Method resolution order: PromptTemplateSubstitutionRequest pydantic.main.BaseModel builtins.object Data descriptors defined here: __weakref__ list of weak references to the object (if defined) Data and other attributes defined here: __abstractmethods__ = frozenset() __annotations__ = {'input_params': typing.Optional[typing.Dict[typing.Any, typing.Any]]} __class_vars__ = set() __private_attributes__ = {} __pydantic_complete__ = True __pydantic_computed_fields__ = {} __pydantic_core_schema__ = {'cls': <class 'gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateSubstitutionRequest'>, 'config': {'title': 'PromptTemplateSubstitutionRequest', 'validate_by_alias': True, 'validate_by_name': True}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...mpt_template.PromptTemplateSubstitutionRequest'>>]}, 'ref': 'gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateSubstitutionRequest:140540950956080', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'input_params': {'metadata': {}, 'schema': {'default_factory': <class 'dict'>, 'default_factory_takes_data': False, 'schema': {'schema': {...}, 'type': 'nullable'}, 'type': 'default'}, 'serialization_alias': 'inputParams', 'type': 'model-field', 'validation_alias': 'inputParams'}}, 'model_name': 'PromptTemplateSubstitutionRequest', 'type': 'model-fields'}, 'type': 'model'} __pydantic_custom_init__ = False __pydantic_decorators__ = DecoratorInfos(validators={}, field_validators={...zers={}, model_validators={}, computed_fields={}) __pydantic_extra_info__ = None __pydantic_fields__ = {'input_params': FieldInfo(annotation=Union[Dict[Any, Any], NoneT...tory=dict, alias='inputParams', alias_priority=2)} __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'parameters': ()} __pydantic_parent_namespace__ = None __pydantic_post_init__ = None __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTrampoli...led_from_config: false, }, ), definitions=[]) __pydantic_setattr_handlers__ = {} __pydantic_validator__ = SchemaValidator(title="PromptTemplateSubstitutio...t", }, ), definitions=[], cache_strings=True) __signature__ = <Signature (*, inputParams: Optional[Dict[Any, Any]] = <factory>) -> None> model_config = {'populate_by_name': True, 'validate_by_alias': True, 'validate_by_name': True} Methods inherited from pydantic.main.BaseModel: __copy__(self) -> 'Self' Returns a shallow copy of the model. __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self' Returns a deep copy of the model. __delattr__(self, item: 'str') -> 'Any' Implement delattr(self, name). __eq__(self, other: 'Any') -> 'bool' Return self==value. __getattr__(self, item: 'str') -> 'Any' __getstate__(self) -> 'dict[Any, Any]' __init__(self, /, **data: 'Any') -> 'None' Create a new model by parsing and validating input data from keyword arguments.   Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.   `self` is explicitly positional-only to allow `self` as a field name. __iter__(self) -> 'TupleGenerator' So `dict(model)` works. __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects. __replace__(self, **changes: 'Any') -> 'Self' # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block: __repr__(self) -> 'str' Return repr(self). __repr_args__(self) -> '_repr.ReprArgs' __repr_name__(self) -> 'str' Name of the instance's class, used in __repr__. __repr_recursion__(self, object: 'Any') -> 'str' Returns the string representation of a recursive object. __repr_str__(self, join_str: 'str') -> 'str' __rich_repr__(self) -> 'RichReprResult' Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects. __setattr__(self, name: 'str', value: 'Any') -> 'None' Implement setattr(self, name, value). __setstate__(self, state: 'dict[Any, Any]') -> 'None' __str__(self) -> 'str' Return str(self). copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self' Returns a copy of the model.   !!! warning "Deprecated"     This method is now deprecated; use `model_copy` instead.   If you need `include` or `exclude`, use:   ```python {test="skip" lint="skip"} data = self.model_dump(include=include, exclude=exclude, round_trip=True) data = {**data, **(update or {})} copied = self.model_validate(data) ```   Args:     include: Optional set or mapping specifying which fields to include in the copied model.     exclude: Optional set or mapping specifying which fields to exclude in the copied model.     update: Optional dictionary of field-value pairs to override field values in the copied model.     deep: If True, the values of fields that are Pydantic models will be deep-copied.   Returns:     A copy of the model with included, excluded and updated fields as specified. dict(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False) -> 'Dict[str, Any]' json(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str' model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self' !!! abstract "Usage Documentation"     [`model_copy`](../concepts/models.md#model-copy)   Returns a copy of the model.   !!! note     The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This     might have unexpected side effects if you store anything in it, on top of the model     fields (e.g. the value of [cached properties][functools.cached_property]).   Args:     update: Values to change/add in the new model. Note: the data is not validated         before creating the new model. You should trust this data.     deep: Set to `True` to make a deep copy of the model.   Returns:     New model instance. model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]' !!! abstract "Usage Documentation"     [`model_dump`](../concepts/serialization.md#python-mode)   Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.   Args:     mode: The mode in which `to_python` should run.         If mode is 'json', the output will only contain JSON serializable types.         If mode is 'python', the output may contain non-JSON-serializable Python objects.     include: A set of fields to include in the output.     exclude: A set of fields to exclude from the output.     context: Additional context to pass to the serializer.     by_alias: Whether to use the field's alias in the dictionary key if defined.     exclude_unset: Whether to exclude fields that have not been explicitly set.     exclude_defaults: Whether to exclude fields that are set to their default value.     exclude_none: Whether to exclude fields that have a value of `None`.     exclude_computed_fields: Whether to exclude computed fields.         While this can be useful for round-tripping, it is usually recommended to use the dedicated         `round_trip` parameter instead.     round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].     warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,         "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].     fallback: A function to call when an unknown value is encountered. If not provided,         a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.     serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.     polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.   Returns:     A dictionary representation of the model. model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str' !!! abstract "Usage Documentation"     [`model_dump_json`](../concepts/serialization.md#json-mode)   Generates a JSON representation of the model using Pydantic's `to_json` method.   Args:     indent: Indentation to use in the JSON output. If None is passed, the output will be compact.     ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.         If `False` (the default), these characters will be output as-is.     include: Field(s) to include in the JSON output.     exclude: Field(s) to exclude from the JSON output.     context: Additional context to pass to the serializer.     by_alias: Whether to serialize using field aliases.     exclude_unset: Whether to exclude fields that have not been explicitly set.     exclude_defaults: Whether to exclude fields that are set to their default value.     exclude_none: Whether to exclude fields that have a value of `None`.     exclude_computed_fields: Whether to exclude computed fields.         While this can be useful for round-tripping, it is usually recommended to use the dedicated         `round_trip` parameter instead.     round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].     warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,         "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].     fallback: A function to call when an unknown value is encountered. If not provided,         a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.     serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.     polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.   Returns:     A JSON string representation of the model. model_post_init(self, context: 'Any', /) -> 'None' Override this method to perform additional initialization after `__init__` and `model_construct`. This is useful if you want to do some validation that requires the entire model to be initialized. Class methods inherited from pydantic.main.BaseModel: __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef' from pydantic._internal._model_construction.ModelMetaclass __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema' from pydantic._internal._model_construction.ModelMetaclass __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue' from pydantic._internal._model_construction.ModelMetaclass Hook into generating the model's JSON schema.   Args:     core_schema: A `pydantic-core` CoreSchema.         You can ignore this argument and call the handler with a new CoreSchema,         wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),         or just call the handler with the original schema.     handler: Call into Pydantic's internal JSON schema generation.         This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema         generation fails.         Since this gets called by `BaseModel.model_json_schema` you can override the         `schema_generator` argument to that function to change JSON schema generation globally         for a type.   Returns:     A JSON schema, as a Python object. __pydantic_init_subclass__(**kwargs: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass` only after basic class initialization is complete. In particular, attributes like `model_fields` will be present when this is called, but forward annotations are not guaranteed to be resolved yet, meaning that creating an instance of the class may fail.   This is necessary because `__init_subclass__` will always be called by `type.__new__`, and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that `type.__new__` was called in such a manner that the class would already be sufficiently initialized.   This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely, any kwargs passed to the class definition that aren't used internally by Pydantic.   Args:     **kwargs: Any keyword arguments passed to the class definition that aren't used internally         by Pydantic.   Note:     You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]     instead, which is called once the class and its fields are fully initialized and ready for validation. __pydantic_on_complete__() -> 'None' from pydantic._internal._model_construction.ModelMetaclass This is called once the class and its fields are fully initialized and ready to be used.   This typically happens when the class is created (just before [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass), except when forward annotations are used that could not immediately be resolved. In that case, it will be called later, when the model is rebuilt automatically or explicitly using [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild]. construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass from_orm(obj: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Creates a new instance of the `Model` class with validated data.   Creates a new model setting `__dict__` and `__pydantic_fields_set__` from trusted or pre-validated data. Default values are respected, but no other validation is performed.   !!! note     `model_construct()` generally respects the `model_config.extra` setting on the provided model.     That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`     and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.     Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in     an error if extra values are passed, but they will be ignored.   Args:     _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,         this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.         Otherwise, the field names from the `values` argument will be used.     values: Trusted or pre-validated data dictionary.   Returns:     A new instance of the `Model` class with validated data. model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]' from pydantic._internal._model_construction.ModelMetaclass Generates a JSON schema for a model class.   Args:     by_alias: Whether to use attribute aliases or not.     ref_template: The reference template.     union_format: The format to use when combining schemas from unions together. Can be one of:           - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)         keyword to combine schemas (the default).         - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)         keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive         type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to         `any_of`.     schema_generator: To override the logic used to generate the JSON schema, as a subclass of         `GenerateJsonSchema` with your desired modifications     mode: The mode in which to generate the schema.   Returns:     The JSON schema for the given model class. model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str' from pydantic._internal._model_construction.ModelMetaclass Compute the class name for parametrizations of generic classes.   This method can be overridden to achieve a custom naming scheme for generic BaseModels.   Args:     params: Tuple of types of the class. Given a generic class         `Model` with 2 type variables and a concrete model `Model[str, int]`,         the value `(str, int)` would be passed to `params`.   Returns:     String representing the new class where `params` are passed to `cls` as type variables.   Raises:     TypeError: Raised when trying to generate concrete names for non-generic models. model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None' from pydantic._internal._model_construction.ModelMetaclass Try to rebuild the pydantic-core schema for the model.   This may be necessary when one of the annotations is a ForwardRef which could not be resolved during the initial attempt to build the schema, and automatic rebuilding fails.   Args:     force: Whether to force the rebuilding of the model schema, defaults to `False`.     raise_errors: Whether to raise errors, defaults to `True`.     _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.     _types_namespace: The types namespace, defaults to `None`.   Returns:     Returns `None` if the schema is already "complete" and rebuilding was not required.     If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`. model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Validate a pydantic model instance.   Args:     obj: The object to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     from_attributes: Whether to extract data from object attributes.     context: Additional context to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Raises:     ValidationError: If the object could not be validated.   Returns:     The validated model instance. model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass !!! abstract "Usage Documentation"     [JSON Parsing](../concepts/json.md#json-parsing)   Validate the given JSON data against the Pydantic model.   Args:     json_data: The JSON data to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     context: Extra variables to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Returns:     The validated Pydantic model.   Raises:     ValidationError: If `json_data` is not a JSON string or the object could not be validated. model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Validate the given object with string data against the Pydantic model.   Args:     obj: The object containing string data to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     context: Extra variables to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Returns:     The validated Pydantic model. parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass parse_obj(obj: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]' from pydantic._internal._model_construction.ModelMetaclass schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str' from pydantic._internal._model_construction.ModelMetaclass update_forward_refs(**localns: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass validate(value: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Readonly properties inherited from pydantic.main.BaseModel: __fields_set__ model_extra Get extra fields set during validation.   Returns:     A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`. model_fields_set Returns the set of fields that have been explicitly set on this model instance.   Returns:     A set of strings representing the fields that have been set,         i.e. that were not filled from defaults. Data descriptors inherited from pydantic.main.BaseModel: __dict__ dictionary for instance variables (if defined) __pydantic_extra__ __pydantic_fields_set__ __pydantic_private__ Data and other attributes inherited from pydantic.main.BaseModel: __hash__ = None __pydantic_root_model__ = False model_computed_fields = {} model_fields = {'input_params': FieldInfo(annotation=Union[Dict[Any, Any], NoneT...tory=dict, alias='inputParams', alias_priority=2)}   class PromptTemplateSubstitutionResponse(pydantic.main.BaseModel)     PromptTemplateSubstitutionResponse(*, parsed_prompt: List[gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplate], resource: Optional[gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateGetResponse] = None) -&gt; None   Represents a response to a request to substitute a prompt template.   Args:     parsed_prompt: The parsed prompt.       resource: List of TemplateGetResponse objects.     Method resolution order: PromptTemplateSubstitutionResponse pydantic.main.BaseModel builtins.object Data descriptors defined here: __weakref__ list of weak references to the object (if defined) Data and other attributes defined here: __abstractmethods__ = frozenset() __annotations__ = {'parsed_prompt': typing.List[gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplate], 'resource': typing.Optional[gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateGetResponse]} __class_vars__ = set() __private_attributes__ = {} __pydantic_complete__ = True __pydantic_computed_fields__ = {} __pydantic_core_schema__ = {'cls': <class 'gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateSubstitutionResponse'>, 'config': {'title': 'PromptTemplateSubstitutionResponse'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...pt_template.PromptTemplateSubstitutionResponse'>>]}, 'ref': 'gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplateSubstitutionResponse:140540950958096', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'parsed_prompt': {'metadata': {}, 'schema': {'items_schema': {'cls': <class 'gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplate'>, 'config': {...}, 'custom_init': False, 'metadata': {...}, 'ref': 'gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplate:140540951190128', 'root_model': False, 'schema': {...}, 'type': 'model'}, 'type': 'list'}, 'type': 'model-field'}, 'resource': {'metadata': {}, 'schema': {'default': None, 'schema': {'schema': {...}, 'type': 'nullable'}, 'type': 'default'}, 'type': 'model-field'}}, 'model_name': 'PromptTemplateSubstitutionResponse', 'type': 'model-fields'}, 'type': 'model'} __pydantic_custom_init__ = False __pydantic_decorators__ = DecoratorInfos(validators={}, field_validators={...zers={}, model_validators={}, computed_fields={}) __pydantic_extra_info__ = None __pydantic_fields__ = {'parsed_prompt': FieldInfo(annotation=List[PromptTemplate], required=True), 'resource': FieldInfo(annotation=Union[PromptTemplateGetResponse, NoneType], required=False, default=None)} __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'parameters': ()} __pydantic_parent_namespace__ = None __pydantic_post_init__ = None __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTrampoli...led_from_config: false, }, ), definitions=[]) __pydantic_setattr_handlers__ = {} __pydantic_validator__ = SchemaValidator(title="PromptTemplateSubstitutio...e", }, ), definitions=[], cache_strings=True) __signature__ = <Signature (*, parsed_prompt: List[gen_ai_hub.pr...plate.PromptTemplateGetResponse] = None) -> None> model_config = {} Methods inherited from pydantic.main.BaseModel: __copy__(self) -> 'Self' Returns a shallow copy of the model. __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self' Returns a deep copy of the model. __delattr__(self, item: 'str') -> 'Any' Implement delattr(self, name). __eq__(self, other: 'Any') -> 'bool' Return self==value. __getattr__(self, item: 'str') -> 'Any' __getstate__(self) -> 'dict[Any, Any]' __init__(self, /, **data: 'Any') -> 'None' Create a new model by parsing and validating input data from keyword arguments.   Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.   `self` is explicitly positional-only to allow `self` as a field name. __iter__(self) -> 'TupleGenerator' So `dict(model)` works. __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects. __replace__(self, **changes: 'Any') -> 'Self' # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block: __repr__(self) -> 'str' Return repr(self). __repr_args__(self) -> '_repr.ReprArgs' __repr_name__(self) -> 'str' Name of the instance's class, used in __repr__. __repr_recursion__(self, object: 'Any') -> 'str' Returns the string representation of a recursive object. __repr_str__(self, join_str: 'str') -> 'str' __rich_repr__(self) -> 'RichReprResult' Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects. __setattr__(self, name: 'str', value: 'Any') -> 'None' Implement setattr(self, name, value). __setstate__(self, state: 'dict[Any, Any]') -> 'None' __str__(self) -> 'str' Return str(self). copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self' Returns a copy of the model.   !!! warning "Deprecated"     This method is now deprecated; use `model_copy` instead.   If you need `include` or `exclude`, use:   ```python {test="skip" lint="skip"} data = self.model_dump(include=include, exclude=exclude, round_trip=True) data = {**data, **(update or {})} copied = self.model_validate(data) ```   Args:     include: Optional set or mapping specifying which fields to include in the copied model.     exclude: Optional set or mapping specifying which fields to exclude in the copied model.     update: Optional dictionary of field-value pairs to override field values in the copied model.     deep: If True, the values of fields that are Pydantic models will be deep-copied.   Returns:     A copy of the model with included, excluded and updated fields as specified. dict(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False) -> 'Dict[str, Any]' json(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str' model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self' !!! abstract "Usage Documentation"     [`model_copy`](../concepts/models.md#model-copy)   Returns a copy of the model.   !!! note     The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This     might have unexpected side effects if you store anything in it, on top of the model     fields (e.g. the value of [cached properties][functools.cached_property]).   Args:     update: Values to change/add in the new model. Note: the data is not validated         before creating the new model. You should trust this data.     deep: Set to `True` to make a deep copy of the model.   Returns:     New model instance. model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]' !!! abstract "Usage Documentation"     [`model_dump`](../concepts/serialization.md#python-mode)   Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.   Args:     mode: The mode in which `to_python` should run.         If mode is 'json', the output will only contain JSON serializable types.         If mode is 'python', the output may contain non-JSON-serializable Python objects.     include: A set of fields to include in the output.     exclude: A set of fields to exclude from the output.     context: Additional context to pass to the serializer.     by_alias: Whether to use the field's alias in the dictionary key if defined.     exclude_unset: Whether to exclude fields that have not been explicitly set.     exclude_defaults: Whether to exclude fields that are set to their default value.     exclude_none: Whether to exclude fields that have a value of `None`.     exclude_computed_fields: Whether to exclude computed fields.         While this can be useful for round-tripping, it is usually recommended to use the dedicated         `round_trip` parameter instead.     round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].     warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,         "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].     fallback: A function to call when an unknown value is encountered. If not provided,         a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.     serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.     polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.   Returns:     A dictionary representation of the model. model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str' !!! abstract "Usage Documentation"     [`model_dump_json`](../concepts/serialization.md#json-mode)   Generates a JSON representation of the model using Pydantic's `to_json` method.   Args:     indent: Indentation to use in the JSON output. If None is passed, the output will be compact.     ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.         If `False` (the default), these characters will be output as-is.     include: Field(s) to include in the JSON output.     exclude: Field(s) to exclude from the JSON output.     context: Additional context to pass to the serializer.     by_alias: Whether to serialize using field aliases.     exclude_unset: Whether to exclude fields that have not been explicitly set.     exclude_defaults: Whether to exclude fields that are set to their default value.     exclude_none: Whether to exclude fields that have a value of `None`.     exclude_computed_fields: Whether to exclude computed fields.         While this can be useful for round-tripping, it is usually recommended to use the dedicated         `round_trip` parameter instead.     round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].     warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,         "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].     fallback: A function to call when an unknown value is encountered. If not provided,         a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.     serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.     polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.   Returns:     A JSON string representation of the model. model_post_init(self, context: 'Any', /) -> 'None' Override this method to perform additional initialization after `__init__` and `model_construct`. This is useful if you want to do some validation that requires the entire model to be initialized. Class methods inherited from pydantic.main.BaseModel: __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef' from pydantic._internal._model_construction.ModelMetaclass __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema' from pydantic._internal._model_construction.ModelMetaclass __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue' from pydantic._internal._model_construction.ModelMetaclass Hook into generating the model's JSON schema.   Args:     core_schema: A `pydantic-core` CoreSchema.         You can ignore this argument and call the handler with a new CoreSchema,         wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),         or just call the handler with the original schema.     handler: Call into Pydantic's internal JSON schema generation.         This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema         generation fails.         Since this gets called by `BaseModel.model_json_schema` you can override the         `schema_generator` argument to that function to change JSON schema generation globally         for a type.   Returns:     A JSON schema, as a Python object. __pydantic_init_subclass__(**kwargs: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass` only after basic class initialization is complete. In particular, attributes like `model_fields` will be present when this is called, but forward annotations are not guaranteed to be resolved yet, meaning that creating an instance of the class may fail.   This is necessary because `__init_subclass__` will always be called by `type.__new__`, and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that `type.__new__` was called in such a manner that the class would already be sufficiently initialized.   This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely, any kwargs passed to the class definition that aren't used internally by Pydantic.   Args:     **kwargs: Any keyword arguments passed to the class definition that aren't used internally         by Pydantic.   Note:     You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]     instead, which is called once the class and its fields are fully initialized and ready for validation. __pydantic_on_complete__() -> 'None' from pydantic._internal._model_construction.ModelMetaclass This is called once the class and its fields are fully initialized and ready to be used.   This typically happens when the class is created (just before [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass), except when forward annotations are used that could not immediately be resolved. In that case, it will be called later, when the model is rebuilt automatically or explicitly using [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild]. construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass from_orm(obj: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Creates a new instance of the `Model` class with validated data.   Creates a new model setting `__dict__` and `__pydantic_fields_set__` from trusted or pre-validated data. Default values are respected, but no other validation is performed.   !!! note     `model_construct()` generally respects the `model_config.extra` setting on the provided model.     That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`     and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.     Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in     an error if extra values are passed, but they will be ignored.   Args:     _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,         this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.         Otherwise, the field names from the `values` argument will be used.     values: Trusted or pre-validated data dictionary.   Returns:     A new instance of the `Model` class with validated data. model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]' from pydantic._internal._model_construction.ModelMetaclass Generates a JSON schema for a model class.   Args:     by_alias: Whether to use attribute aliases or not.     ref_template: The reference template.     union_format: The format to use when combining schemas from unions together. Can be one of:           - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)         keyword to combine schemas (the default).         - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)         keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive         type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to         `any_of`.     schema_generator: To override the logic used to generate the JSON schema, as a subclass of         `GenerateJsonSchema` with your desired modifications     mode: The mode in which to generate the schema.   Returns:     The JSON schema for the given model class. model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str' from pydantic._internal._model_construction.ModelMetaclass Compute the class name for parametrizations of generic classes.   This method can be overridden to achieve a custom naming scheme for generic BaseModels.   Args:     params: Tuple of types of the class. Given a generic class         `Model` with 2 type variables and a concrete model `Model[str, int]`,         the value `(str, int)` would be passed to `params`.   Returns:     String representing the new class where `params` are passed to `cls` as type variables.   Raises:     TypeError: Raised when trying to generate concrete names for non-generic models. model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None' from pydantic._internal._model_construction.ModelMetaclass Try to rebuild the pydantic-core schema for the model.   This may be necessary when one of the annotations is a ForwardRef which could not be resolved during the initial attempt to build the schema, and automatic rebuilding fails.   Args:     force: Whether to force the rebuilding of the model schema, defaults to `False`.     raise_errors: Whether to raise errors, defaults to `True`.     _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.     _types_namespace: The types namespace, defaults to `None`.   Returns:     Returns `None` if the schema is already "complete" and rebuilding was not required.     If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`. model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Validate a pydantic model instance.   Args:     obj: The object to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     from_attributes: Whether to extract data from object attributes.     context: Additional context to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Raises:     ValidationError: If the object could not be validated.   Returns:     The validated model instance. model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass !!! abstract "Usage Documentation"     [JSON Parsing](../concepts/json.md#json-parsing)   Validate the given JSON data against the Pydantic model.   Args:     json_data: The JSON data to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     context: Extra variables to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Returns:     The validated Pydantic model.   Raises:     ValidationError: If `json_data` is not a JSON string or the object could not be validated. model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Validate the given object with string data against the Pydantic model.   Args:     obj: The object containing string data to validate.     strict: Whether to enforce types strictly.     extra: Whether to ignore, allow, or forbid extra data during model validation.         See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.     context: Extra variables to pass to the validator.     by_alias: Whether to use the field's alias when validating against the provided input data.     by_name: Whether to use the field's name when validating against the provided input data.   Returns:     The validated Pydantic model. parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass parse_obj(obj: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]' from pydantic._internal._model_construction.ModelMetaclass schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str' from pydantic._internal._model_construction.ModelMetaclass update_forward_refs(**localns: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass validate(value: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass Readonly properties inherited from pydantic.main.BaseModel: __fields_set__ model_extra Get extra fields set during validation.   Returns:     A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`. model_fields_set Returns the set of fields that have been explicitly set on this model instance.   Returns:     A set of strings representing the fields that have been set,         i.e. that were not filled from defaults. Data descriptors inherited from pydantic.main.BaseModel: __dict__ dictionary for instance variables (if defined) __pydantic_extra__ __pydantic_fields_set__ __pydantic_private__ Data and other attributes inherited from pydantic.main.BaseModel: __hash__ = None __pydantic_root_model__ = False model_computed_fields = {} model_fields = {'parsed_prompt': FieldInfo(annotation=List[PromptTemplate], required=True), 'resource': FieldInfo(annotation=Union[PromptTemplateGetResponse, NoneType], required=False, default=None)}