gen_ai_hub.prompt_registry.models.prompt_template
index
/home/jenkins/agent/workspace/ation_generative-ai-hub-sdk_main/gen_ai_hub/prompt_registry/models/prompt_template.py

 
Classes
       
pydantic.main.BaseModel(builtins.object)
PromptTemplate
PromptTemplateDeleteResponse
PromptTemplateGetResponse
PromptTemplateListResponse
PromptTemplatePostRequest
PromptTemplatePostResponse
PromptTemplateSpec
PromptTemplateSubstitutionRequest
PromptTemplateSubstitutionResponse

 
class PromptTemplate(pydantic.main.BaseModel)
    PromptTemplate(*, role: str, content: str) -> 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

Data descriptors defined here:
__weakref__
list of weak references to the object (if defined)

Data and other attributes defined here:
__abstractmethods__ = frozenset()
__annotations__ = {'content': <class 'str'>, '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:139830613209712', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'content': {'metadata': {}, 'schema': {'type': 'str'}, '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_fields__ = {'content': FieldInfo(annotation=str, 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=Model( ModelSeri...name: "PromptTemplate", }, ), definitions=[])
__pydantic_setattr_handlers__ = {}
__pydantic_validator__ = SchemaValidator(title="PromptTemplate", validato...e", }, ), definitions=[], cache_strings=True)
__signature__ = <Signature (*, role: str, content: 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: 'typing.Callable[[Any], Any]', **kwargs: 'Any') -> 'typing.Generator[Any, None, None]'
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/serialization.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, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False) -> 'dict[str, Any]'
!!! abstract "Usage Documentation"
    [`model_dump`](../concepts/serialization.md#modelmodel_dump)
 
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`.
    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.
 
Returns:
    A dictionary representation of the model.
model_dump_json(self, *, indent: 'int | None' = None, 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, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False) -> 'str'
!!! abstract "Usage Documentation"
    [`model_dump_json`](../concepts/serialization.md#modelmodel_dump_json)
 
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.
    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`.
    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.
 
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 the class is actually fully initialized. In particular, attributes like `model_fields` will
be present when this is called.
 
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.
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') -> '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.
    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, 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.
    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, 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.
    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, 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.
    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=str, required=True), 'role': FieldInfo(annotation=str, required=True)}

 
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:139830612935344', '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_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=Model( ModelSeri...emplateDeleteResponse", }, ), 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: 'typing.Callable[[Any], Any]', **kwargs: 'Any') -> 'typing.Generator[Any, None, None]'
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/serialization.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, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False) -> 'dict[str, Any]'
!!! abstract "Usage Documentation"
    [`model_dump`](../concepts/serialization.md#modelmodel_dump)
 
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`.
    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.
 
Returns:
    A dictionary representation of the model.
model_dump_json(self, *, indent: 'int | None' = None, 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, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False) -> 'str'
!!! abstract "Usage Documentation"
    [`model_dump_json`](../concepts/serialization.md#modelmodel_dump_json)
 
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.
    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`.
    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.
 
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 the class is actually fully initialized. In particular, attributes like `model_fields` will
be present when this is called.
 
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.
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') -> '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.
    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, 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.
    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, 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.
    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, 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.
    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:139830612931280', '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_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=Model( ModelSeri...ptTemplateGetResponse", }, ), 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: 'typing.Callable[[Any], Any]', **kwargs: 'Any') -> 'typing.Generator[Any, None, None]'
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/serialization.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, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False) -> 'dict[str, Any]'
!!! abstract "Usage Documentation"
    [`model_dump`](../concepts/serialization.md#modelmodel_dump)
 
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`.
    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.
 
Returns:
    A dictionary representation of the model.
model_dump_json(self, *, indent: 'int | None' = None, 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, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False) -> 'str'
!!! abstract "Usage Documentation"
    [`model_dump_json`](../concepts/serialization.md#modelmodel_dump_json)
 
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.
    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`.
    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.
 
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 the class is actually fully initialized. In particular, attributes like `model_fields` will
be present when this is called.
 
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.
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') -> '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.
    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, 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.
    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, 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.
    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, 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.
    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:139830612934320', '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:139830612931280', '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_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=Model( ModelSeri...tTemplateListResponse", }, ), 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: 'typing.Callable[[Any], Any]', **kwargs: 'Any') -> 'typing.Generator[Any, None, None]'
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/serialization.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, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False) -> 'dict[str, Any]'
!!! abstract "Usage Documentation"
    [`model_dump`](../concepts/serialization.md#modelmodel_dump)
 
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`.
    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.
 
Returns:
    A dictionary representation of the model.
model_dump_json(self, *, indent: 'int | None' = None, 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, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False) -> 'str'
!!! abstract "Usage Documentation"
    [`model_dump_json`](../concepts/serialization.md#modelmodel_dump_json)
 
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.
    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`.
    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.
 
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 the class is actually fully initialized. In particular, attributes like `model_fields` will
be present when this is called.
 
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.
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') -> '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.
    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, 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.
    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, 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.
    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, 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.
    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:139830612928304', '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:139830612920208', '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_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=Model( ModelSeri...ptTemplatePostRequest", }, ), 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: 'typing.Callable[[Any], Any]', **kwargs: 'Any') -> 'typing.Generator[Any, None, None]'
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/serialization.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, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False) -> 'dict[str, Any]'
!!! abstract "Usage Documentation"
    [`model_dump`](../concepts/serialization.md#modelmodel_dump)
 
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`.
    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.
 
Returns:
    A dictionary representation of the model.
model_dump_json(self, *, indent: 'int | None' = None, 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, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False) -> 'str'
!!! abstract "Usage Documentation"
    [`model_dump_json`](../concepts/serialization.md#modelmodel_dump_json)
 
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.
    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`.
    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.
 
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 the class is actually fully initialized. In particular, attributes like `model_fields` will
be present when this is called.
 
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.
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') -> '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.
    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, 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.
    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, 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.
    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, 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.
    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:139830612929264', '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_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=Model( ModelSeri...tTemplatePostResponse", }, ), 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: 'typing.Callable[[Any], Any]', **kwargs: 'Any') -> 'typing.Generator[Any, None, None]'
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/serialization.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, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False) -> 'dict[str, Any]'
!!! abstract "Usage Documentation"
    [`model_dump`](../concepts/serialization.md#modelmodel_dump)
 
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`.
    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.
 
Returns:
    A dictionary representation of the model.
model_dump_json(self, *, indent: 'int | None' = None, 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, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False) -> 'str'
!!! abstract "Usage Documentation"
    [`model_dump_json`](../concepts/serialization.md#modelmodel_dump_json)
 
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.
    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`.
    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.
 
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 the class is actually fully initialized. In particular, attributes like `model_fields` will
be present when this is called.
 
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.
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') -> '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.
    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, 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.
    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, 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.
    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, 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.
    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[Any, Any]] = &lt;factory&gt;, additional_fields: Optional[Dict[Any, Any]] = &lt;factory&gt;) -&gt; None
 
Represents a prompt template specification.
 
Args:
    template: The list of prompt templates.
    defaults: The default values for the prompt template fields.
    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[typing.Dict[typing.Any, typing.Any]], 'template': typing.List[gen_ai_hub.prompt_registry.models.prompt_template.PromptTemplate]}
__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:139830612920208', '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_factory': <class 'dict'>, 'default_factory_takes_data': False, '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:139830613209712', 'root_model': False, 'schema': {...}, 'type': 'model'}, 'type': 'list'}, '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_fields__ = {'additional_fields': FieldInfo(annotation=Union[Dict[Any, Any], NoneType], required=False, default_factory=dict), 'defaults': FieldInfo(annotation=Union[Dict[Any, Any], NoneType], required=False, default_factory=dict), 'template': FieldInfo(annotation=List[PromptTemplate], required=True)}
__pydantic_generic_metadata__ = {'args': (), 'origin': None, 'parameters': ()}
__pydantic_parent_namespace__ = None
__pydantic_post_init__ = None
__pydantic_serializer__ = SchemaSerializer(serializer=Model( ModelSeri...: "PromptTemplateSpec", }, ), 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: 'typing.Callable[[Any], Any]', **kwargs: 'Any') -> 'typing.Generator[Any, None, None]'
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/serialization.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, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False) -> 'dict[str, Any]'
!!! abstract "Usage Documentation"
    [`model_dump`](../concepts/serialization.md#modelmodel_dump)
 
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`.
    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.
 
Returns:
    A dictionary representation of the model.
model_dump_json(self, *, indent: 'int | None' = None, 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, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False) -> 'str'
!!! abstract "Usage Documentation"
    [`model_dump_json`](../concepts/serialization.md#modelmodel_dump_json)
 
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.
    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`.
    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.
 
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 the class is actually fully initialized. In particular, attributes like `model_fields` will
be present when this is called.
 
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.
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') -> '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.
    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, 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.
    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, 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.
    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, 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.
    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[Any, Any], NoneType], required=False, default_factory=dict), 'template': FieldInfo(annotation=List[PromptTemplate], required=True)}

 
class PromptTemplateSubstitutionRequest(pydantic.main.BaseModel)
    PromptTemplateSubstitutionRequest(*, input_params: 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'}, '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:139830612937360', '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'}, 'type': 'model-field'}}, 'model_name': 'PromptTemplateSubstitutionRequest', 'type': 'model-fields'}, 'type': 'model'}
__pydantic_custom_init__ = False
__pydantic_decorators__ = DecoratorInfos(validators={}, field_validators={...zers={}, model_validators={}, computed_fields={})
__pydantic_fields__ = {'input_params': FieldInfo(annotation=Union[Dict[Any, Any], NoneType], required=False, default_factory=dict)}
__pydantic_generic_metadata__ = {'args': (), 'origin': None, 'parameters': ()}
__pydantic_parent_namespace__ = None
__pydantic_post_init__ = None
__pydantic_serializer__ = SchemaSerializer(serializer=Model( ModelSeri...teSubstitutionRequest", }, ), definitions=[])
__pydantic_setattr_handlers__ = {}
__pydantic_validator__ = SchemaValidator(title="PromptTemplateSubstitutio...t", }, ), definitions=[], cache_strings=True)
__signature__ = <Signature (*, input_params: 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: 'typing.Callable[[Any], Any]', **kwargs: 'Any') -> 'typing.Generator[Any, None, None]'
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/serialization.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, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False) -> 'dict[str, Any]'
!!! abstract "Usage Documentation"
    [`model_dump`](../concepts/serialization.md#modelmodel_dump)
 
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`.
    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.
 
Returns:
    A dictionary representation of the model.
model_dump_json(self, *, indent: 'int | None' = None, 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, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False) -> 'str'
!!! abstract "Usage Documentation"
    [`model_dump_json`](../concepts/serialization.md#modelmodel_dump_json)
 
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.
    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`.
    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.
 
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 the class is actually fully initialized. In particular, attributes like `model_fields` will
be present when this is called.
 
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.
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') -> '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.
    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, 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.
    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, 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.
    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, 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.
    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], NoneType], required=False, default_factory=dict)}

 
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:139830612939392', '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:139830613209712', '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_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=Model( ModelSeri...eSubstitutionResponse", }, ), 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: 'typing.Callable[[Any], Any]', **kwargs: 'Any') -> 'typing.Generator[Any, None, None]'
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/serialization.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, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False) -> 'dict[str, Any]'
!!! abstract "Usage Documentation"
    [`model_dump`](../concepts/serialization.md#modelmodel_dump)
 
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`.
    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.
 
Returns:
    A dictionary representation of the model.
model_dump_json(self, *, indent: 'int | None' = None, 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, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False) -> 'str'
!!! abstract "Usage Documentation"
    [`model_dump_json`](../concepts/serialization.md#modelmodel_dump_json)
 
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.
    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`.
    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.
 
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 the class is actually fully initialized. In particular, attributes like `model_fields` will
be present when this is called.
 
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.
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') -> '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.
    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, 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.
    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, 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.
    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, 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.
    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)}

 
Data
        Any = typing.Any
Dict = typing.Dict
List = typing.List
Optional = typing.Optional