| | |
- builtins.object
-
- GenAIHubRestClient
- builtins.str(builtins.object)
-
- InvalidDeploymentBehavior(builtins.str, enum.Enum)
- enum.Enum(builtins.object)
-
- InvalidDeploymentBehavior(builtins.str, enum.Enum)
- gen_ai_hub.proxy.core.base.BaseDeployment(pydantic.main.BaseModel, abc.ABC)
-
- Deployment
- gen_ai_hub.proxy.core.base.BaseProxyClient(abc.ABC, pydantic.main.BaseModel)
-
- GenAIHubProxyClient
- pydantic.main.BaseModel(builtins.object)
-
- FoundationalModelScenario
class Deployment(gen_ai_hub.proxy.core.base.BaseDeployment) |
| |
Deployment(*, url: str, config_id: str, config_name: str, deployment_id: str, model_name: str, created_at: datetime.datetime, additonal_parameters: Dict[str, str] = <factory>, custom_prediction_suffix: Optional[str] = None) -> None
Deployment class represents a deployment of a foundational model in the GenAI Hub.
|
| |
- Method resolution order:
- Deployment
- gen_ai_hub.proxy.core.base.BaseDeployment
- pydantic.main.BaseModel
- abc.ABC
- builtins.object
Methods defined here:
- __getattr__(self, name)
- Get attribute from additional parameters if not found in the Deployment instance.
:param name: Attribute name to get.
:type name: str
:raises err: If attribute not found in both Deployment instance and additional parameters.
:return: Attribute value.
:rtype: Any
- additional_request_body_kwargs(self) -> 'Dict[str, Any]'
- # abstractmethod implementations
Class methods defined here:
- get_model_identification_kwargs() -> 'Tuple[str]' from pydantic._internal._model_construction.ModelMetaclass
- Get model identification keywords.
:return: Tuple of model identification keywords.
:rtype: Tuple[str]
Readonly properties defined here:
- prediction_url
Data and other attributes defined here:
- __abstractmethods__ = frozenset()
- __annotations__ = {'additonal_parameters': 'Dict[str, str]', 'config_id': 'str', 'config_name': 'str', 'created_at': 'datetime', 'custom_prediction_suffix': 'Optional[str]', 'deployment_id': 'str', 'model_name': 'str', 'prediction_urls': 'ClassVar[PredictionURLs]', 'url': 'str'}
- __class_vars__ = {'prediction_urls'}
- __private_attributes__ = {}
- __pydantic_complete__ = True
- __pydantic_computed_fields__ = {}
- __pydantic_core_schema__ = {'cls': <class 'gen_ai_hub.proxy.gen_ai_hub_proxy.client.Deployment'>, 'config': {'title': 'Deployment'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...i_hub.proxy.gen_ai_hub_proxy.client.Deployment'>>]}, 'ref': 'gen_ai_hub.proxy.gen_ai_hub_proxy.client.Deployment:139913918160688', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'additonal_parameters': {'metadata': {}, 'schema': {'default_factory': <class 'dict'>, 'default_factory_takes_data': False, 'schema': {'keys_schema': {...}, 'type': 'dict', 'values_schema': {...}}, 'type': 'default'}, 'type': 'model-field'}, 'config_id': {'metadata': {}, 'schema': {'type': 'str'}, 'type': 'model-field'}, 'config_name': {'metadata': {}, 'schema': {'type': 'str'}, 'type': 'model-field'}, 'created_at': {'metadata': {}, 'schema': {'microseconds_precision': 'truncate', 'type': 'datetime'}, 'type': 'model-field'}, 'custom_prediction_suffix': {'metadata': {}, 'schema': {'default': None, 'schema': {'schema': {...}, 'type': 'nullable'}, 'type': 'default'}, 'type': 'model-field'}, 'deployment_id': {'metadata': {}, 'schema': {'type': 'str'}, 'type': 'model-field'}, 'model_name': {'metadata': {}, 'schema': {'type': 'str'}, 'type': 'model-field'}, 'url': {'metadata': {}, 'schema': {'type': 'str'}, 'type': 'model-field'}}, 'model_name': 'Deployment', 'type': 'model-fields'}, 'type': 'model'}
- __pydantic_custom_init__ = False
- __pydantic_decorators__ = DecoratorInfos(validators={}, field_validators={...zers={}, model_validators={}, computed_fields={})
- __pydantic_fields__ = {'additonal_parameters': FieldInfo(annotation=Dict[str, str], required=False, default_factory=dict), 'config_id': FieldInfo(annotation=str, required=True), 'config_name': FieldInfo(annotation=str, required=True), 'created_at': FieldInfo(annotation=datetime, required=True), 'custom_prediction_suffix': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'deployment_id': FieldInfo(annotation=str, required=True), 'model_name': FieldInfo(annotation=str, required=True), 'url': 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: "Deployment",
},
), definitions=[])
- __pydantic_setattr_handlers__ = {}
- __pydantic_validator__ = SchemaValidator(title="Deployment", validator=Mo...t",
},
), definitions=[], cache_strings=True)
- __signature__ = <Signature (*, url: str, config_id: str, config_...prediction_suffix: Optional[str] = None) -> None>
- model_config = {'protected_namespaces': ()}
- prediction_urls = <gen_ai_hub.proxy.core.utils.PredictionURLs object>
Class methods inherited from gen_ai_hub.proxy.core.base.BaseDeployment:
- get_main_model_identification_kwargs() -> 'str' from pydantic._internal._model_construction.ModelMetaclass
Data descriptors inherited from gen_ai_hub.proxy.core.base.BaseDeployment:
- __weakref__
- list of weak references to the object (if defined)
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.
- __getstate__(self) -> 'dict[Any, Any]'
- __init__(self, /, **data: 'Any') -> 'None'
- Create a new model by parsing and validating input data from keyword arguments.
Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be
validated to form a valid model.
`self` is explicitly positional-only to allow `self` as a field name.
- __iter__(self) -> 'TupleGenerator'
- So `dict(model)` works.
- __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]'
- Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
- __replace__(self, **changes: 'Any') -> 'Self'
- # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by
# type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block:
- __repr__(self) -> 'str'
- Return repr(self).
- __repr_args__(self) -> '_repr.ReprArgs'
- __repr_name__(self) -> 'str'
- Name of the instance's class, used in __repr__.
- __repr_recursion__(self, object: 'Any') -> 'str'
- Returns the string representation of a recursive object.
- __repr_str__(self, join_str: 'str') -> 'str'
- __rich_repr__(self) -> 'RichReprResult'
- Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.
- __setattr__(self, name: 'str', value: 'Any') -> 'None'
- Implement setattr(self, name, value).
- __setstate__(self, state: 'dict[Any, Any]') -> 'None'
- __str__(self) -> 'str'
- Return str(self).
- copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
- Returns a copy of the model.
!!! warning "Deprecated"
This method is now deprecated; use `model_copy` instead.
If you need `include` or `exclude`, use:
```python {test="skip" lint="skip"}
data = self.model_dump(include=include, exclude=exclude, round_trip=True)
data = {**data, **(update or {})}
copied = self.model_validate(data)
```
Args:
include: Optional set or mapping specifying which fields to include in the copied model.
exclude: Optional set or mapping specifying which fields to exclude in the copied model.
update: Optional dictionary of field-value pairs to override field values in the copied model.
deep: If True, the values of fields that are Pydantic models will be deep-copied.
Returns:
A copy of the model with included, excluded and updated fields as specified.
- dict(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False) -> 'Dict[str, Any]'
- json(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str'
- model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
- !!! abstract "Usage Documentation"
[`model_copy`](../concepts/models.md#model-copy)
Returns a copy of the model.
!!! note
The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
might have unexpected side effects if you store anything in it, on top of the model
fields (e.g. the value of [cached properties][functools.cached_property]).
Args:
update: Values to change/add in the new model. Note: the data is not validated
before creating the new model. You should trust this data.
deep: Set to `True` to make a deep copy of the model.
Returns:
New model instance.
- model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False) -> 'dict[str, Any]'
- !!! abstract "Usage Documentation"
[`model_dump`](../concepts/serialization.md#python-mode)
Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
Args:
mode: The mode in which `to_python` should run.
If mode is 'json', the output will only contain JSON serializable types.
If mode is 'python', the output may contain non-JSON-serializable Python objects.
include: A set of fields to include in the output.
exclude: A set of fields to exclude from the output.
context: Additional context to pass to the serializer.
by_alias: Whether to use the field's alias in the dictionary key if defined.
exclude_unset: Whether to exclude fields that have not been explicitly set.
exclude_defaults: Whether to exclude fields that are set to their default value.
exclude_none: Whether to exclude fields that have a value of `None`.
exclude_computed_fields: Whether to exclude computed fields.
While this can be useful for round-tripping, it is usually recommended to use the dedicated
`round_trip` parameter instead.
round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
"error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
fallback: A function to call when an unknown value is encountered. If not provided,
a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
Returns:
A dictionary representation of the model.
- model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False) -> 'str'
- !!! abstract "Usage Documentation"
[`model_dump_json`](../concepts/serialization.md#json-mode)
Generates a JSON representation of the model using Pydantic's `to_json` method.
Args:
indent: Indentation to use in the JSON output. If None is passed, the output will be compact.
ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
If `False` (the default), these characters will be output as-is.
include: Field(s) to include in the JSON output.
exclude: Field(s) to exclude from the JSON output.
context: Additional context to pass to the serializer.
by_alias: Whether to serialize using field aliases.
exclude_unset: Whether to exclude fields that have not been explicitly set.
exclude_defaults: Whether to exclude fields that are set to their default value.
exclude_none: Whether to exclude fields that have a value of `None`.
exclude_computed_fields: Whether to exclude computed fields.
While this can be useful for round-tripping, it is usually recommended to use the dedicated
`round_trip` parameter instead.
round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
"error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
fallback: A function to call when an unknown value is encountered. If not provided,
a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
Returns:
A JSON string representation of the model.
- model_post_init(self, context: 'Any', /) -> 'None'
- Override this method to perform additional initialization after `__init__` and `model_construct`.
This is useful if you want to do some validation that requires the entire model to be initialized.
Class methods inherited from pydantic.main.BaseModel:
- __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef' from pydantic._internal._model_construction.ModelMetaclass
- __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema' from pydantic._internal._model_construction.ModelMetaclass
- __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue' from pydantic._internal._model_construction.ModelMetaclass
- Hook into generating the model's JSON schema.
Args:
core_schema: A `pydantic-core` CoreSchema.
You can ignore this argument and call the handler with a new CoreSchema,
wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),
or just call the handler with the original schema.
handler: Call into Pydantic's internal JSON schema generation.
This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema
generation fails.
Since this gets called by `BaseModel.model_json_schema` you can override the
`schema_generator` argument to that function to change JSON schema generation globally
for a type.
Returns:
A JSON schema, as a Python object.
- __pydantic_init_subclass__(**kwargs: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass
- This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass`
only after basic class initialization is complete. In particular, attributes like `model_fields` will
be present when this is called, but forward annotations are not guaranteed to be resolved yet,
meaning that creating an instance of the class may fail.
This is necessary because `__init_subclass__` will always be called by `type.__new__`,
and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that
`type.__new__` was called in such a manner that the class would already be sufficiently initialized.
This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely,
any kwargs passed to the class definition that aren't used internally by Pydantic.
Args:
**kwargs: Any keyword arguments passed to the class definition that aren't used internally
by Pydantic.
Note:
You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]
instead, which is called once the class and its fields are fully initialized and ready for validation.
- __pydantic_on_complete__() -> 'None' from pydantic._internal._model_construction.ModelMetaclass
- This is called once the class and its fields are fully initialized and ready to be used.
This typically happens when the class is created (just before
[`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass),
except when forward annotations are used that could not immediately be resolved.
In that case, it will be called later, when the model is rebuilt automatically or explicitly using
[`model_rebuild()`][pydantic.main.BaseModel.model_rebuild].
- construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass
- from_orm(obj: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass
- model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass
- Creates a new instance of the `Model` class with validated data.
Creates a new model setting `__dict__` and `__pydantic_fields_set__` from trusted or pre-validated data.
Default values are respected, but no other validation is performed.
!!! note
`model_construct()` generally respects the `model_config.extra` setting on the provided model.
That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`
and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.
Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in
an error if extra values are passed, but they will be ignored.
Args:
_fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.
Otherwise, the field names from the `values` argument will be used.
values: Trusted or pre-validated data dictionary.
Returns:
A new instance of the `Model` class with validated data.
- model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]' from pydantic._internal._model_construction.ModelMetaclass
- Generates a JSON schema for a model class.
Args:
by_alias: Whether to use attribute aliases or not.
ref_template: The reference template.
union_format: The format to use when combining schemas from unions together. Can be one of:
- `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
keyword to combine schemas (the default).
- `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
`any_of`.
schema_generator: To override the logic used to generate the JSON schema, as a subclass of
`GenerateJsonSchema` with your desired modifications
mode: The mode in which to generate the schema.
Returns:
The JSON schema for the given model class.
- model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str' from pydantic._internal._model_construction.ModelMetaclass
- Compute the class name for parametrizations of generic classes.
This method can be overridden to achieve a custom naming scheme for generic BaseModels.
Args:
params: Tuple of types of the class. Given a generic class
`Model` with 2 type variables and a concrete model `Model[str, int]`,
the value `(str, int)` would be passed to `params`.
Returns:
String representing the new class where `params` are passed to `cls` as type variables.
Raises:
TypeError: Raised when trying to generate concrete names for non-generic models.
- model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None' from pydantic._internal._model_construction.ModelMetaclass
- Try to rebuild the pydantic-core schema for the model.
This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
the initial attempt to build the schema, and automatic rebuilding fails.
Args:
force: Whether to force the rebuilding of the model schema, defaults to `False`.
raise_errors: Whether to raise errors, defaults to `True`.
_parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
_types_namespace: The types namespace, defaults to `None`.
Returns:
Returns `None` if the schema is already "complete" and rebuilding was not required.
If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
- model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass
- Validate a pydantic model instance.
Args:
obj: The object to validate.
strict: Whether to enforce types strictly.
extra: Whether to ignore, allow, or forbid extra data during model validation.
See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
from_attributes: Whether to extract data from object attributes.
context: Additional context to pass to the validator.
by_alias: Whether to use the field's alias when validating against the provided input data.
by_name: Whether to use the field's name when validating against the provided input data.
Raises:
ValidationError: If the object could not be validated.
Returns:
The validated model instance.
- model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass
- !!! abstract "Usage Documentation"
[JSON Parsing](../concepts/json.md#json-parsing)
Validate the given JSON data against the Pydantic model.
Args:
json_data: The JSON data to validate.
strict: Whether to enforce types strictly.
extra: Whether to ignore, allow, or forbid extra data during model validation.
See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
context: Extra variables to pass to the validator.
by_alias: Whether to use the field's alias when validating against the provided input data.
by_name: Whether to use the field's name when validating against the provided input data.
Returns:
The validated Pydantic model.
Raises:
ValidationError: If `json_data` is not a JSON string or the object could not be validated.
- model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass
- Validate the given object with string data against the Pydantic model.
Args:
obj: The object containing string data to validate.
strict: Whether to enforce types strictly.
extra: Whether to ignore, allow, or forbid extra data during model validation.
See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
context: Extra variables to pass to the validator.
by_alias: Whether to use the field's alias when validating against the provided input data.
by_name: Whether to use the field's name when validating against the provided input data.
Returns:
The validated Pydantic model.
- parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass
- parse_obj(obj: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass
- parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass
- schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]' from pydantic._internal._model_construction.ModelMetaclass
- schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str' from pydantic._internal._model_construction.ModelMetaclass
- update_forward_refs(**localns: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass
- validate(value: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass
Readonly properties inherited from pydantic.main.BaseModel:
- __fields_set__
- model_extra
- Get extra fields set during validation.
Returns:
A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.
- model_fields_set
- Returns the set of fields that have been explicitly set on this model instance.
Returns:
A set of strings representing the fields that have been set,
i.e. that were not filled from defaults.
Data descriptors inherited from pydantic.main.BaseModel:
- __dict__
- dictionary for instance variables (if defined)
- __pydantic_extra__
- __pydantic_fields_set__
- __pydantic_private__
Data and other attributes inherited from pydantic.main.BaseModel:
- __hash__ = None
- __pydantic_root_model__ = False
- model_computed_fields = {}
- model_fields = {'additonal_parameters': FieldInfo(annotation=Dict[str, str], required=False, default_factory=dict), 'config_id': FieldInfo(annotation=str, required=True), 'config_name': FieldInfo(annotation=str, required=True), 'created_at': FieldInfo(annotation=datetime, required=True), 'custom_prediction_suffix': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'deployment_id': FieldInfo(annotation=str, required=True), 'model_name': FieldInfo(annotation=str, required=True), 'url': FieldInfo(annotation=str, required=True)}
|
class FoundationalModelScenario(pydantic.main.BaseModel) |
| |
FoundationalModelScenario(*, scenario_id: str, config_names: Union[List[str], str, NoneType] = None, model_name_parameter: str = 'model_name', prediction_url_suffix: Optional[str] = None) -> None
Represents a foundational model scenario in the GenAI Hub.
|
| |
- Method resolution order:
- FoundationalModelScenario
- pydantic.main.BaseModel
- builtins.object
Class methods defined here:
- adjust(data: 'Any') -> 'Any' from pydantic._internal._model_construction.ModelMetaclass
- Adjust input data before model initialization.
:param data: Input data to adjust.
:type data: Any
:return: Adjusted data.
:rtype: Any
Data descriptors defined here:
- __weakref__
- list of weak references to the object (if defined)
Data and other attributes defined here:
- __abstractmethods__ = frozenset()
- __annotations__ = {'config_names': 'Optional[Union[List[str], str]]', 'model_name_parameter': 'str', 'prediction_url_suffix': 'Optional[str]', 'scenario_id': 'str'}
- __class_vars__ = set()
- __private_attributes__ = {}
- __pydantic_complete__ = True
- __pydantic_computed_fields__ = {}
- __pydantic_core_schema__ = {'cls': <class 'gen_ai_hub.proxy.gen_ai_hub_proxy.client.FoundationalModelScenario'>, 'config': {'title': 'FoundationalModelScenario'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche..._ai_hub_proxy.client.FoundationalModelScenario'>>]}, 'ref': 'gen_ai_hub.proxy.gen_ai_hub_proxy.client.FoundationalModelScenario:139913902272352', 'root_model': False, 'schema': {'function': {'function': <bound method FoundationalModelScenario.adjust o..._ai_hub_proxy.client.FoundationalModelScenario'>>, 'type': 'no-info'}, 'schema': {'computed_fields': [], 'fields': {'config_names': {'metadata': {}, 'schema': {'default': None, 'schema': {...}, 'type': 'default'}, 'type': 'model-field'}, 'model_name_parameter': {'metadata': {}, 'schema': {'default': 'model_name', 'schema': {...}, 'type': 'default'}, 'type': 'model-field'}, 'prediction_url_suffix': {'metadata': {}, 'schema': {'default': None, 'schema': {...}, 'type': 'default'}, 'type': 'model-field'}, 'scenario_id': {'metadata': {}, 'schema': {'type': 'str'}, 'type': 'model-field'}}, 'model_name': 'FoundationalModelScenario', 'type': 'model-fields'}, 'type': 'function-before'}, 'type': 'model'}
- __pydantic_custom_init__ = False
- __pydantic_decorators__ = DecoratorInfos(validators={}, field_validators={...coratorInfo(mode='before'))}, computed_fields={})
- __pydantic_fields__ = {'config_names': FieldInfo(annotation=Union[List[str], str, NoneType], required=False, default=None), 'model_name_parameter': FieldInfo(annotation=str, required=False, default='model_name'), 'prediction_url_suffix': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'scenario_id': 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...dationalModelScenario",
},
), definitions=[])
- __pydantic_setattr_handlers__ = {}
- __pydantic_validator__ = SchemaValidator(title="FoundationalModelScenario...o",
},
), definitions=[], cache_strings=True)
- __signature__ = <Signature (*, scenario_id: str, config_names: U...iction_url_suffix: Optional[str] = None) -> None>
- model_config = {'protected_namespaces': ()}
Methods inherited from pydantic.main.BaseModel:
- __copy__(self) -> 'Self'
- Returns a shallow copy of the model.
- __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self'
- Returns a deep copy of the model.
- __delattr__(self, item: 'str') -> 'Any'
- Implement delattr(self, name).
- __eq__(self, other: 'Any') -> 'bool'
- Return self==value.
- __getattr__(self, item: 'str') -> 'Any'
- __getstate__(self) -> 'dict[Any, Any]'
- __init__(self, /, **data: 'Any') -> 'None'
- Create a new model by parsing and validating input data from keyword arguments.
Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be
validated to form a valid model.
`self` is explicitly positional-only to allow `self` as a field name.
- __iter__(self) -> 'TupleGenerator'
- So `dict(model)` works.
- __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]'
- Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
- __replace__(self, **changes: 'Any') -> 'Self'
- # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by
# type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block:
- __repr__(self) -> 'str'
- Return repr(self).
- __repr_args__(self) -> '_repr.ReprArgs'
- __repr_name__(self) -> 'str'
- Name of the instance's class, used in __repr__.
- __repr_recursion__(self, object: 'Any') -> 'str'
- Returns the string representation of a recursive object.
- __repr_str__(self, join_str: 'str') -> 'str'
- __rich_repr__(self) -> 'RichReprResult'
- Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.
- __setattr__(self, name: 'str', value: 'Any') -> 'None'
- Implement setattr(self, name, value).
- __setstate__(self, state: 'dict[Any, Any]') -> 'None'
- __str__(self) -> 'str'
- Return str(self).
- copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
- Returns a copy of the model.
!!! warning "Deprecated"
This method is now deprecated; use `model_copy` instead.
If you need `include` or `exclude`, use:
```python {test="skip" lint="skip"}
data = self.model_dump(include=include, exclude=exclude, round_trip=True)
data = {**data, **(update or {})}
copied = self.model_validate(data)
```
Args:
include: Optional set or mapping specifying which fields to include in the copied model.
exclude: Optional set or mapping specifying which fields to exclude in the copied model.
update: Optional dictionary of field-value pairs to override field values in the copied model.
deep: If True, the values of fields that are Pydantic models will be deep-copied.
Returns:
A copy of the model with included, excluded and updated fields as specified.
- dict(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False) -> 'Dict[str, Any]'
- json(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str'
- model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
- !!! abstract "Usage Documentation"
[`model_copy`](../concepts/models.md#model-copy)
Returns a copy of the model.
!!! note
The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
might have unexpected side effects if you store anything in it, on top of the model
fields (e.g. the value of [cached properties][functools.cached_property]).
Args:
update: Values to change/add in the new model. Note: the data is not validated
before creating the new model. You should trust this data.
deep: Set to `True` to make a deep copy of the model.
Returns:
New model instance.
- model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False) -> 'dict[str, Any]'
- !!! abstract "Usage Documentation"
[`model_dump`](../concepts/serialization.md#python-mode)
Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
Args:
mode: The mode in which `to_python` should run.
If mode is 'json', the output will only contain JSON serializable types.
If mode is 'python', the output may contain non-JSON-serializable Python objects.
include: A set of fields to include in the output.
exclude: A set of fields to exclude from the output.
context: Additional context to pass to the serializer.
by_alias: Whether to use the field's alias in the dictionary key if defined.
exclude_unset: Whether to exclude fields that have not been explicitly set.
exclude_defaults: Whether to exclude fields that are set to their default value.
exclude_none: Whether to exclude fields that have a value of `None`.
exclude_computed_fields: Whether to exclude computed fields.
While this can be useful for round-tripping, it is usually recommended to use the dedicated
`round_trip` parameter instead.
round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
"error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
fallback: A function to call when an unknown value is encountered. If not provided,
a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
Returns:
A dictionary representation of the model.
- model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False) -> 'str'
- !!! abstract "Usage Documentation"
[`model_dump_json`](../concepts/serialization.md#json-mode)
Generates a JSON representation of the model using Pydantic's `to_json` method.
Args:
indent: Indentation to use in the JSON output. If None is passed, the output will be compact.
ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
If `False` (the default), these characters will be output as-is.
include: Field(s) to include in the JSON output.
exclude: Field(s) to exclude from the JSON output.
context: Additional context to pass to the serializer.
by_alias: Whether to serialize using field aliases.
exclude_unset: Whether to exclude fields that have not been explicitly set.
exclude_defaults: Whether to exclude fields that are set to their default value.
exclude_none: Whether to exclude fields that have a value of `None`.
exclude_computed_fields: Whether to exclude computed fields.
While this can be useful for round-tripping, it is usually recommended to use the dedicated
`round_trip` parameter instead.
round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
"error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
fallback: A function to call when an unknown value is encountered. If not provided,
a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
Returns:
A JSON string representation of the model.
- model_post_init(self, context: 'Any', /) -> 'None'
- Override this method to perform additional initialization after `__init__` and `model_construct`.
This is useful if you want to do some validation that requires the entire model to be initialized.
Class methods inherited from pydantic.main.BaseModel:
- __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef' from pydantic._internal._model_construction.ModelMetaclass
- __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema' from pydantic._internal._model_construction.ModelMetaclass
- __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue' from pydantic._internal._model_construction.ModelMetaclass
- Hook into generating the model's JSON schema.
Args:
core_schema: A `pydantic-core` CoreSchema.
You can ignore this argument and call the handler with a new CoreSchema,
wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),
or just call the handler with the original schema.
handler: Call into Pydantic's internal JSON schema generation.
This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema
generation fails.
Since this gets called by `BaseModel.model_json_schema` you can override the
`schema_generator` argument to that function to change JSON schema generation globally
for a type.
Returns:
A JSON schema, as a Python object.
- __pydantic_init_subclass__(**kwargs: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass
- This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass`
only after basic class initialization is complete. In particular, attributes like `model_fields` will
be present when this is called, but forward annotations are not guaranteed to be resolved yet,
meaning that creating an instance of the class may fail.
This is necessary because `__init_subclass__` will always be called by `type.__new__`,
and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that
`type.__new__` was called in such a manner that the class would already be sufficiently initialized.
This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely,
any kwargs passed to the class definition that aren't used internally by Pydantic.
Args:
**kwargs: Any keyword arguments passed to the class definition that aren't used internally
by Pydantic.
Note:
You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]
instead, which is called once the class and its fields are fully initialized and ready for validation.
- __pydantic_on_complete__() -> 'None' from pydantic._internal._model_construction.ModelMetaclass
- This is called once the class and its fields are fully initialized and ready to be used.
This typically happens when the class is created (just before
[`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass),
except when forward annotations are used that could not immediately be resolved.
In that case, it will be called later, when the model is rebuilt automatically or explicitly using
[`model_rebuild()`][pydantic.main.BaseModel.model_rebuild].
- construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass
- from_orm(obj: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass
- model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass
- Creates a new instance of the `Model` class with validated data.
Creates a new model setting `__dict__` and `__pydantic_fields_set__` from trusted or pre-validated data.
Default values are respected, but no other validation is performed.
!!! note
`model_construct()` generally respects the `model_config.extra` setting on the provided model.
That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`
and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.
Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in
an error if extra values are passed, but they will be ignored.
Args:
_fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.
Otherwise, the field names from the `values` argument will be used.
values: Trusted or pre-validated data dictionary.
Returns:
A new instance of the `Model` class with validated data.
- model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]' from pydantic._internal._model_construction.ModelMetaclass
- Generates a JSON schema for a model class.
Args:
by_alias: Whether to use attribute aliases or not.
ref_template: The reference template.
union_format: The format to use when combining schemas from unions together. Can be one of:
- `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
keyword to combine schemas (the default).
- `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
`any_of`.
schema_generator: To override the logic used to generate the JSON schema, as a subclass of
`GenerateJsonSchema` with your desired modifications
mode: The mode in which to generate the schema.
Returns:
The JSON schema for the given model class.
- model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str' from pydantic._internal._model_construction.ModelMetaclass
- Compute the class name for parametrizations of generic classes.
This method can be overridden to achieve a custom naming scheme for generic BaseModels.
Args:
params: Tuple of types of the class. Given a generic class
`Model` with 2 type variables and a concrete model `Model[str, int]`,
the value `(str, int)` would be passed to `params`.
Returns:
String representing the new class where `params` are passed to `cls` as type variables.
Raises:
TypeError: Raised when trying to generate concrete names for non-generic models.
- model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None' from pydantic._internal._model_construction.ModelMetaclass
- Try to rebuild the pydantic-core schema for the model.
This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
the initial attempt to build the schema, and automatic rebuilding fails.
Args:
force: Whether to force the rebuilding of the model schema, defaults to `False`.
raise_errors: Whether to raise errors, defaults to `True`.
_parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
_types_namespace: The types namespace, defaults to `None`.
Returns:
Returns `None` if the schema is already "complete" and rebuilding was not required.
If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
- model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass
- Validate a pydantic model instance.
Args:
obj: The object to validate.
strict: Whether to enforce types strictly.
extra: Whether to ignore, allow, or forbid extra data during model validation.
See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
from_attributes: Whether to extract data from object attributes.
context: Additional context to pass to the validator.
by_alias: Whether to use the field's alias when validating against the provided input data.
by_name: Whether to use the field's name when validating against the provided input data.
Raises:
ValidationError: If the object could not be validated.
Returns:
The validated model instance.
- model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass
- !!! abstract "Usage Documentation"
[JSON Parsing](../concepts/json.md#json-parsing)
Validate the given JSON data against the Pydantic model.
Args:
json_data: The JSON data to validate.
strict: Whether to enforce types strictly.
extra: Whether to ignore, allow, or forbid extra data during model validation.
See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
context: Extra variables to pass to the validator.
by_alias: Whether to use the field's alias when validating against the provided input data.
by_name: Whether to use the field's name when validating against the provided input data.
Returns:
The validated Pydantic model.
Raises:
ValidationError: If `json_data` is not a JSON string or the object could not be validated.
- model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass
- Validate the given object with string data against the Pydantic model.
Args:
obj: The object containing string data to validate.
strict: Whether to enforce types strictly.
extra: Whether to ignore, allow, or forbid extra data during model validation.
See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
context: Extra variables to pass to the validator.
by_alias: Whether to use the field's alias when validating against the provided input data.
by_name: Whether to use the field's name when validating against the provided input data.
Returns:
The validated Pydantic model.
- parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass
- parse_obj(obj: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass
- parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from pydantic._internal._model_construction.ModelMetaclass
- schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]' from pydantic._internal._model_construction.ModelMetaclass
- schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str' from pydantic._internal._model_construction.ModelMetaclass
- update_forward_refs(**localns: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass
- validate(value: 'Any') -> 'Self' from pydantic._internal._model_construction.ModelMetaclass
Readonly properties inherited from pydantic.main.BaseModel:
- __fields_set__
- model_extra
- Get extra fields set during validation.
Returns:
A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.
- model_fields_set
- Returns the set of fields that have been explicitly set on this model instance.
Returns:
A set of strings representing the fields that have been set,
i.e. that were not filled from defaults.
Data descriptors inherited from pydantic.main.BaseModel:
- __dict__
- dictionary for instance variables (if defined)
- __pydantic_extra__
- __pydantic_fields_set__
- __pydantic_private__
Data and other attributes inherited from pydantic.main.BaseModel:
- __hash__ = None
- __pydantic_root_model__ = False
- model_computed_fields = {}
- model_fields = {'config_names': FieldInfo(annotation=Union[List[str], str, NoneType], required=False, default=None), 'model_name_parameter': FieldInfo(annotation=str, required=False, default='model_name'), 'prediction_url_suffix': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'scenario_id': FieldInfo(annotation=str, required=True)}
|
class GenAIHubProxyClient(gen_ai_hub.proxy.core.base.BaseProxyClient) |
| |
GenAIHubProxyClient(*, base_url: Optional[str] = None, auth_url: Optional[str] = None, client_id: Optional[str] = None, client_secret: Optional[str] = None, resource_group: Optional[str] = None, ai_core_client: Optional[ai_core_sdk.ai_core_v2_client.AICoreV2Client] = None, **extra_data: Any) -> None
GenAIHubProxyClient is a proxy client for interacting with the GenAI Hub.
|
| |
- Method resolution order:
- GenAIHubProxyClient
- gen_ai_hub.proxy.core.base.BaseProxyClient
- abc.ABC
- pydantic.main.BaseModel
- builtins.object
Methods defined here:
- get_additional_headers(self) -> 'Dict[str, str]'
- Get only the additional headers (instance-level and request-level).
:return: Additional headers.
:rtype: Dict[str, str]
- get_ai_core_token(self)
- Get the AI core token for authentication.
:return: AI core token.
:rtype: str
- get_deployments(self)
- Get the list of deployments.
:return: List of deployments.
:rtype: List[Deployment]
- get_request_header(self)
- Get the request headers for requests made by the client.
:return: Request headers.
:rtype: Dict[str, str]
- model_post_init = init_private_attributes(self: 'BaseModel', context: 'Any', /) -> 'None'
- This function is meant to behave like a BaseModel method to initialise private attributes.
It takes context as an argument since that's what pydantic-core passes when calling it.
Args:
self: The BaseModel instance.
context: The context.
- select_deployment(self, raise_on_multiple: 'bool' = False, **search_key_value)
- set_headers_addition(self, headers: 'Dict[str, str]')
- Set additional headers for requests made by the client.
:param headers: Headers to add.
:type headers: Dict[str, str]
- update_deployments(self)
- Update the list of deployments from the GenAI Hub.
:return: List of updated deployments.
:rtype: List[Deployment]
Class methods defined here:
- add_foundation_model_scenario(scenario_id, config_names: 'Optional[List[str]]' = None, prediction_url_suffix: 'Optional[str]' = None, model_name_parameter: 'str' = 'model_name') from gen_ai_hub.proxy.core.base.CombinedMeta
- Add a foundational model scenario to the client.
:param scenario_id: the scenario ID.
:type scenario_id: str
:param config_names: list of configuration names, defaults to None
:type config_names: Optional[List[str]], optional
:param prediction_url_suffix: prediction URL suffix, defaults to None
:type prediction_url_suffix: Optional[str], optional
:param model_name_parameter: model name parameter, defaults to 'model_name'
:type model_name_parameter: str, optional
- for_profile(profile: 'str' = None) from gen_ai_hub.proxy.core.base.CombinedMeta
- Create a GenAIHubProxyClient instance for the given profile.
:param profile: Profile name, defaults to None
:type profile: str, optional
:return: GenAIHubProxyClient instance.
:rtype: GenAIHubProxyClient
- init_client(data: 'Any') -> 'Any' from gen_ai_hub.proxy.core.base.CombinedMeta
- Initialize the client with the provided data.
:param data: Input data for client initialization.
:type data: Any
:return: Initialized data.
:rtype: Any
- set_default_values(**kwargs) from gen_ai_hub.proxy.core.base.CombinedMeta
- Set default values for the client.
Readonly properties defined here:
- deployment_class
- deployments
- request_header
Data and other attributes defined here:
- AI_CLIENT_TYPE_VAL = 'GenAI Hub SDK (Python)'
- __abstractmethods__ = frozenset()
- __annotations__ = {'AI_CLIENT_TYPE_VAL': 'ClassVar[str]', '_deployments': 'List[Deployment]', '_headers_addition': 'Dict[str, str]', 'ai_core_client': 'Optional[AICoreV2Client]', 'auth_url': 'Optional[str]', 'base_url': 'Optional[str]', 'client_id': 'Optional[str]', 'client_secret': 'Optional[str]', 'default_values': 'ClassVar[Dict[str, Any]]', 'foundational_model_scenarios': 'ClassVar[List[FoundationalModelScenario]]', ...}
- __class_vars__ = {'AI_CLIENT_TYPE_VAL', 'default_values', 'foundational_model_scenarios', 'on_invalid_deployments'}
- __private_attributes__ = {'_deployments': ModelPrivateAttr(default=PydanticUndefined, default_factory=<class 'list'>), '_headers_addition': ModelPrivateAttr(default={})}
- __pydantic_complete__ = True
- __pydantic_computed_fields__ = {}
- __pydantic_core_schema__ = {'cls': <class 'gen_ai_hub.proxy.gen_ai_hub_proxy.client.GenAIHubProxyClient'>, 'config': {'extra_fields_behavior': 'allow', 'title': 'GenAIHubProxyClient'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...xy.gen_ai_hub_proxy.client.GenAIHubProxyClient'>>]}, 'post_init': 'model_post_init', 'ref': 'gen_ai_hub.proxy.gen_ai_hub_proxy.client.GenAIHubProxyClient:139913902274368', 'root_model': False, 'schema': {'function': {'function': <bound method GenAIHubProxyClient.init_client of...xy.gen_ai_hub_proxy.client.GenAIHubProxyClient'>>, 'type': 'no-info'}, 'schema': {'computed_fields': [], 'fields': {'ai_core_client': {'metadata': {}, 'schema': {'default': None, 'schema': {...}, 'type': 'default'}, 'type': 'model-field'}, 'auth_url': {'metadata': {}, 'schema': {'default': None, 'schema': {...}, 'type': 'default'}, 'type': 'model-field'}, 'base_url': {'metadata': {}, 'schema': {'default': None, 'schema': {...}, 'type': 'default'}, 'type': 'model-field'}, 'client_id': {'metadata': {}, 'schema': {'default': None, 'schema': {...}, 'type': 'default'}, 'type': 'model-field'}, 'client_secret': {'metadata': {}, 'schema': {'default': None, 'schema': {...}, 'type': 'default'}, 'type': 'model-field'}, 'resource_group': {'metadata': {}, 'schema': {'default': None, 'schema': {...}, 'type': 'default'}, 'type': 'model-field'}}, 'model_name': 'GenAIHubProxyClient', 'type': 'model-fields'}, 'type': 'function-before'}, 'type': 'model'}
- __pydantic_custom_init__ = False
- __pydantic_decorators__ = DecoratorInfos(validators={}, field_validators={...coratorInfo(mode='before'))}, computed_fields={})
- __pydantic_fields__ = {'ai_core_client': FieldInfo(annotation=Union[AICoreV2Client, NoneType], required=False, default=None), 'auth_url': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'base_url': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'client_id': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'client_secret': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'resource_group': FieldInfo(annotation=Union[str, NoneType], required=False, default=None)}
- __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'parameters': ()}
- __pydantic_parent_namespace__ = None
- __pydantic_post_init__ = 'model_post_init'
- __pydantic_serializer__ = SchemaSerializer(serializer=Model(
ModelSeri... "GenAIHubProxyClient",
},
), definitions=[])
- __pydantic_setattr_handlers__ = {}
- __pydantic_validator__ = SchemaValidator(title="GenAIHubProxyClient", val...t",
},
), definitions=[], cache_strings=True)
- __signature__ = <Signature (*, base_url: Optional[str] = None, a...CoreV2Client] = None, **extra_data: Any) -> None>
- default_values = {}
- foundational_model_scenarios = [FoundationalModelScenario(scenario_id='foundatio...rameter='model_name', prediction_url_suffix=None)]
- model_config = {'arbitrary_types_allowed': True, 'extra': 'allow', 'protected_namespaces': ()}
- on_invalid_deployments = <InvalidDeploymentBehavior.warn: 'warn'>
Class methods inherited from gen_ai_hub.proxy.core.base.BaseProxyClient:
- refresh_instance_cache() from gen_ai_hub.proxy.core.base.CombinedMeta
- Refresh the cache of instances.
Data descriptors inherited from gen_ai_hub.proxy.core.base.BaseProxyClient:
- __weakref__
- list of weak references to the object (if defined)
Methods inherited from pydantic.main.BaseModel:
- __copy__(self) -> 'Self'
- Returns a shallow copy of the model.
- __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self'
- Returns a deep copy of the model.
- __delattr__(self, item: 'str') -> 'Any'
- Implement delattr(self, name).
- __eq__(self, other: 'Any') -> 'bool'
- Return self==value.
- __getattr__(self, item: 'str') -> 'Any'
- __getstate__(self) -> 'dict[Any, Any]'
- __init__(self, /, **data: 'Any') -> 'None'
- Create a new model by parsing and validating input data from keyword arguments.
Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be
validated to form a valid model.
`self` is explicitly positional-only to allow `self` as a field name.
- __iter__(self) -> 'TupleGenerator'
- So `dict(model)` works.
- __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]'
- Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
- __replace__(self, **changes: 'Any') -> 'Self'
- # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by
# type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block:
- __repr__(self) -> 'str'
- Return repr(self).
- __repr_args__(self) -> '_repr.ReprArgs'
- __repr_name__(self) -> 'str'
- Name of the instance's class, used in __repr__.
- __repr_recursion__(self, object: 'Any') -> 'str'
- Returns the string representation of a recursive object.
- __repr_str__(self, join_str: 'str') -> 'str'
- __rich_repr__(self) -> 'RichReprResult'
- Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.
- __setattr__(self, name: 'str', value: 'Any') -> 'None'
- Implement setattr(self, name, value).
- __setstate__(self, state: 'dict[Any, Any]') -> 'None'
- __str__(self) -> 'str'
- Return str(self).
- copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
- Returns a copy of the model.
!!! warning "Deprecated"
This method is now deprecated; use `model_copy` instead.
If you need `include` or `exclude`, use:
```python {test="skip" lint="skip"}
data = self.model_dump(include=include, exclude=exclude, round_trip=True)
data = {**data, **(update or {})}
copied = self.model_validate(data)
```
Args:
include: Optional set or mapping specifying which fields to include in the copied model.
exclude: Optional set or mapping specifying which fields to exclude in the copied model.
update: Optional dictionary of field-value pairs to override field values in the copied model.
deep: If True, the values of fields that are Pydantic models will be deep-copied.
Returns:
A copy of the model with included, excluded and updated fields as specified.
- dict(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False) -> 'Dict[str, Any]'
- json(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str'
- model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
- !!! abstract "Usage Documentation"
[`model_copy`](../concepts/models.md#model-copy)
Returns a copy of the model.
!!! note
The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
might have unexpected side effects if you store anything in it, on top of the model
fields (e.g. the value of [cached properties][functools.cached_property]).
Args:
update: Values to change/add in the new model. Note: the data is not validated
before creating the new model. You should trust this data.
deep: Set to `True` to make a deep copy of the model.
Returns:
New model instance.
- model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False) -> 'dict[str, Any]'
- !!! abstract "Usage Documentation"
[`model_dump`](../concepts/serialization.md#python-mode)
Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
Args:
mode: The mode in which `to_python` should run.
If mode is 'json', the output will only contain JSON serializable types.
If mode is 'python', the output may contain non-JSON-serializable Python objects.
include: A set of fields to include in the output.
exclude: A set of fields to exclude from the output.
context: Additional context to pass to the serializer.
by_alias: Whether to use the field's alias in the dictionary key if defined.
exclude_unset: Whether to exclude fields that have not been explicitly set.
exclude_defaults: Whether to exclude fields that are set to their default value.
exclude_none: Whether to exclude fields that have a value of `None`.
exclude_computed_fields: Whether to exclude computed fields.
While this can be useful for round-tripping, it is usually recommended to use the dedicated
`round_trip` parameter instead.
round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
"error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
fallback: A function to call when an unknown value is encountered. If not provided,
a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
Returns:
A dictionary representation of the model.
- model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False) -> 'str'
- !!! abstract "Usage Documentation"
[`model_dump_json`](../concepts/serialization.md#json-mode)
Generates a JSON representation of the model using Pydantic's `to_json` method.
Args:
indent: Indentation to use in the JSON output. If None is passed, the output will be compact.
ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
If `False` (the default), these characters will be output as-is.
include: Field(s) to include in the JSON output.
exclude: Field(s) to exclude from the JSON output.
context: Additional context to pass to the serializer.
by_alias: Whether to serialize using field aliases.
exclude_unset: Whether to exclude fields that have not been explicitly set.
exclude_defaults: Whether to exclude fields that are set to their default value.
exclude_none: Whether to exclude fields that have a value of `None`.
exclude_computed_fields: Whether to exclude computed fields.
While this can be useful for round-tripping, it is usually recommended to use the dedicated
`round_trip` parameter instead.
round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
"error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
fallback: A function to call when an unknown value is encountered. If not provided,
a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
Returns:
A JSON string representation of the model.
Class methods inherited from pydantic.main.BaseModel:
- __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef' from gen_ai_hub.proxy.core.base.CombinedMeta
- __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema' from gen_ai_hub.proxy.core.base.CombinedMeta
- __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue' from gen_ai_hub.proxy.core.base.CombinedMeta
- 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 gen_ai_hub.proxy.core.base.CombinedMeta
- This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass`
only after basic class initialization is complete. In particular, attributes like `model_fields` will
be present when this is called, but forward annotations are not guaranteed to be resolved yet,
meaning that creating an instance of the class may fail.
This is necessary because `__init_subclass__` will always be called by `type.__new__`,
and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that
`type.__new__` was called in such a manner that the class would already be sufficiently initialized.
This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely,
any kwargs passed to the class definition that aren't used internally by Pydantic.
Args:
**kwargs: Any keyword arguments passed to the class definition that aren't used internally
by Pydantic.
Note:
You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]
instead, which is called once the class and its fields are fully initialized and ready for validation.
- __pydantic_on_complete__() -> 'None' from gen_ai_hub.proxy.core.base.CombinedMeta
- This is called once the class and its fields are fully initialized and ready to be used.
This typically happens when the class is created (just before
[`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass),
except when forward annotations are used that could not immediately be resolved.
In that case, it will be called later, when the model is rebuilt automatically or explicitly using
[`model_rebuild()`][pydantic.main.BaseModel.model_rebuild].
- construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from gen_ai_hub.proxy.core.base.CombinedMeta
- from_orm(obj: 'Any') -> 'Self' from gen_ai_hub.proxy.core.base.CombinedMeta
- model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self' from gen_ai_hub.proxy.core.base.CombinedMeta
- Creates a new instance of the `Model` class with validated data.
Creates a new model setting `__dict__` and `__pydantic_fields_set__` from trusted or pre-validated data.
Default values are respected, but no other validation is performed.
!!! note
`model_construct()` generally respects the `model_config.extra` setting on the provided model.
That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`
and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.
Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in
an error if extra values are passed, but they will be ignored.
Args:
_fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.
Otherwise, the field names from the `values` argument will be used.
values: Trusted or pre-validated data dictionary.
Returns:
A new instance of the `Model` class with validated data.
- model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]' from gen_ai_hub.proxy.core.base.CombinedMeta
- Generates a JSON schema for a model class.
Args:
by_alias: Whether to use attribute aliases or not.
ref_template: The reference template.
union_format: The format to use when combining schemas from unions together. Can be one of:
- `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
keyword to combine schemas (the default).
- `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
`any_of`.
schema_generator: To override the logic used to generate the JSON schema, as a subclass of
`GenerateJsonSchema` with your desired modifications
mode: The mode in which to generate the schema.
Returns:
The JSON schema for the given model class.
- model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str' from gen_ai_hub.proxy.core.base.CombinedMeta
- 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 gen_ai_hub.proxy.core.base.CombinedMeta
- Try to rebuild the pydantic-core schema for the model.
This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
the initial attempt to build the schema, and automatic rebuilding fails.
Args:
force: Whether to force the rebuilding of the model schema, defaults to `False`.
raise_errors: Whether to raise errors, defaults to `True`.
_parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
_types_namespace: The types namespace, defaults to `None`.
Returns:
Returns `None` if the schema is already "complete" and rebuilding was not required.
If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
- model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from gen_ai_hub.proxy.core.base.CombinedMeta
- Validate a pydantic model instance.
Args:
obj: The object to validate.
strict: Whether to enforce types strictly.
extra: Whether to ignore, allow, or forbid extra data during model validation.
See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
from_attributes: Whether to extract data from object attributes.
context: Additional context to pass to the validator.
by_alias: Whether to use the field's alias when validating against the provided input data.
by_name: Whether to use the field's name when validating against the provided input data.
Raises:
ValidationError: If the object could not be validated.
Returns:
The validated model instance.
- model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from gen_ai_hub.proxy.core.base.CombinedMeta
- !!! abstract "Usage Documentation"
[JSON Parsing](../concepts/json.md#json-parsing)
Validate the given JSON data against the Pydantic model.
Args:
json_data: The JSON data to validate.
strict: Whether to enforce types strictly.
extra: Whether to ignore, allow, or forbid extra data during model validation.
See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
context: Extra variables to pass to the validator.
by_alias: Whether to use the field's alias when validating against the provided input data.
by_name: Whether to use the field's name when validating against the provided input data.
Returns:
The validated Pydantic model.
Raises:
ValidationError: If `json_data` is not a JSON string or the object could not be validated.
- model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self' from gen_ai_hub.proxy.core.base.CombinedMeta
- Validate the given object with string data against the Pydantic model.
Args:
obj: The object containing string data to validate.
strict: Whether to enforce types strictly.
extra: Whether to ignore, allow, or forbid extra data during model validation.
See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
context: Extra variables to pass to the validator.
by_alias: Whether to use the field's alias when validating against the provided input data.
by_name: Whether to use the field's name when validating against the provided input data.
Returns:
The validated Pydantic model.
- parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from gen_ai_hub.proxy.core.base.CombinedMeta
- parse_obj(obj: 'Any') -> 'Self' from gen_ai_hub.proxy.core.base.CombinedMeta
- parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self' from gen_ai_hub.proxy.core.base.CombinedMeta
- schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]' from gen_ai_hub.proxy.core.base.CombinedMeta
- schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str' from gen_ai_hub.proxy.core.base.CombinedMeta
- update_forward_refs(**localns: 'Any') -> 'None' from gen_ai_hub.proxy.core.base.CombinedMeta
- validate(value: 'Any') -> 'Self' from gen_ai_hub.proxy.core.base.CombinedMeta
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 = {'ai_core_client': FieldInfo(annotation=Union[AICoreV2Client, NoneType], required=False, default=None), 'auth_url': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'base_url': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'client_id': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'client_secret': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'resource_group': FieldInfo(annotation=Union[str, NoneType], required=False, default=None)}
|
class GenAIHubRestClient(builtins.object) |
| |
GenAIHubRestClient(proxy_client: "'GenAIHubProxyClient'")
REST client with automatic header injection.
This client wraps the AI Core rest_client and ensures that all requests include:
- Instance-level headers (set via proxy_client.set_headers_addition)
- Request-level headers (set via temporary_headers_addition context manager)
:param proxy_client: The GenAIHubProxyClient instance to get the rest_client and headers from.
|
| |
Methods defined here:
- __init__(self, proxy_client: "'GenAIHubProxyClient'")
- Initialize the GenAIHubRestClient.
:param proxy_client: The GenAIHubProxyClient instance to get the rest_client and headers from.
- delete(self, path: 'str', **kwargs)
- Send a DELETE request with injected headers.
:param path: The API path.
:param kwargs: Additional arguments to pass to the underlying rest_client.
:return: The response from the rest_client.
- get(self, path: 'str', **kwargs)
- Send a GET request with injected headers.
:param path: The API path.
:param kwargs: Additional arguments to pass to the underlying rest_client.
:return: The response from the rest_client.
- patch(self, path: 'str', **kwargs)
- Send a PATCH request with injected headers.
:param path: The API path.
:param kwargs: Additional arguments to pass to the underlying rest_client.
:return: The response from the rest_client.
- post(self, path: 'str', **kwargs)
- Send a POST request with injected headers.
:param path: The API path.
:param kwargs: Additional arguments to pass to the underlying rest_client.
:return: The response from the rest_client.
Data descriptors defined here:
- __dict__
- dictionary for instance variables (if defined)
- __weakref__
- list of weak references to the object (if defined)
|
class InvalidDeploymentBehavior(builtins.str, enum.Enum) |
| |
InvalidDeploymentBehavior(value, names=None, *, module=None, qualname=None, type=None, start=1)
An enumeration.
|
| |
- Method resolution order:
- InvalidDeploymentBehavior
- builtins.str
- enum.Enum
- builtins.object
Data and other attributes defined here:
- ignore = <InvalidDeploymentBehavior.ignore: 'ignore'>
- raise_error = <InvalidDeploymentBehavior.raise_error: 'raise_error'>
- warn = <InvalidDeploymentBehavior.warn: 'warn'>
Data descriptors inherited from enum.Enum:
- name
- The name of the Enum member.
- value
- The value of the Enum member.
Readonly properties inherited from enum.EnumMeta:
- __members__
- Returns a mapping of member name->value.
This mapping lists all enum members, including aliases. Note that this
is a read-only view of the internal mapping.
| |