| | |
- gen_ai_hub.proxy.core.base.BaseProxyClient(abc.ABC, pydantic.main.BaseModel)
-
- gen_ai_hub.proxy.gen_ai_hub_proxy.client.GenAIHubProxyClient
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) -> None
|
| |
- Method resolution order:
- GenAIHubProxyClient
- gen_ai_hub.proxy.core.base.BaseProxyClient
- abc.ABC
- pydantic.main.BaseModel
- builtins.object
Methods defined here:
- get_ai_core_token(self)
- get_deployments(self)
- get_request_header(self)
- 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]')
- # public methods
- update_deployments(self)
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
- for_profile(profile: 'str' = None) from gen_ai_hub.proxy.core.base.CombinedMeta
- init_client(data: 'Any') -> 'Any' from gen_ai_hub.proxy.core.base.CombinedMeta
- set_default_values(**kwargs) from gen_ai_hub.proxy.core.base.CombinedMeta
Readonly properties defined here:
- deployment_class
- deployments
- request_header
Data and other attributes defined here:
- __abstractmethods__ = frozenset()
- __annotations__ = {'_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]]', 'on_invalid_deployments': 'ClassVar[InvalidDeploymentBehavior]', ...}
- __class_vars__ = {'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_core_schema__ = {'cls': <class 'gen_ai_hub.proxy.gen_ai_hub_proxy.client.GenAIHubProxyClient'>, 'config': {'title': 'GenAIHubProxyClient'}, 'custom_init': False, 'metadata': {'pydantic_js_annotation_functions': [], 'pydantic_js_functions': [functools.partial(<function modify_model_json_sc...xy.gen_ai_hub_proxy.client.GenAIHubProxyClient'>), <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:140427274051568', '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': {'pydantic_js_annotation_functions': [...], 'pydantic_js_functions': []}, 'schema': {'default': None, 'schema': {...}, 'type': 'default'}, 'type': 'model-field'}, 'auth_url': {'metadata': {'pydantic_js_annotation_functions': [...], 'pydantic_js_functions': []}, 'schema': {'default': None, 'schema': {...}, 'type': 'default'}, 'type': 'model-field'}, 'base_url': {'metadata': {'pydantic_js_annotation_functions': [...], 'pydantic_js_functions': []}, 'schema': {'default': None, 'schema': {...}, 'type': 'default'}, 'type': 'model-field'}, 'client_id': {'metadata': {'pydantic_js_annotation_functions': [...], 'pydantic_js_functions': []}, 'schema': {'default': None, 'schema': {...}, 'type': 'default'}, 'type': 'model-field'}, 'client_secret': {'metadata': {'pydantic_js_annotation_functions': [...], 'pydantic_js_functions': []}, 'schema': {'default': None, 'schema': {...}, 'type': 'default'}, 'type': 'model-field'}, 'resource_group': {'metadata': {'pydantic_js_annotation_functions': [...], 'pydantic_js_functions': []}, '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_generic_metadata__ = {'args': (), 'origin': None, 'parameters': ()}
- __pydantic_parent_namespace__ = {'AICoreV2Client': <pydantic._internal._model_construction._PydanticWeakRef object>, 'AMAZON_CHAT_COMPLETION': <pydantic._internal._model_construction._PydanticWeakRef object>, 'Any': <pydantic._internal._model_construction._PydanticWeakRef object>, 'BaseDeployment': <pydantic._internal._model_construction._PydanticWeakRef object>, 'BaseModel': <pydantic._internal._model_construction._PydanticWeakRef object>, 'BaseProxyClient': <pydantic._internal._model_construction._PydanticWeakRef object>, 'ClassVar': <pydantic._internal._model_construction._PydanticWeakRef object>, 'ConfigDict': <pydantic._internal._model_construction._PydanticWeakRef object>, 'ContextVar': <pydantic._internal._model_construction._PydanticWeakRef object>, 'Deployment': <pydantic._internal._model_construction._PydanticWeakRef object>, ...}
- __pydantic_post_init__ = 'model_post_init'
- __pydantic_serializer__ = SchemaSerializer(serializer=Model(
ModelSeri... "GenAIHubProxyClient",
},
), definitions=[])
- __pydantic_validator__ = SchemaValidator(title="GenAIHubProxyClient", val...t",
},
), definitions=[], cache_strings=True)
- __signature__ = <Signature (*, base_url: Optional[str] = None, a...i_core_v2_client.AICoreV2Client] = None) -> None>
- default_values = {}
- foundational_model_scenarios = [FoundationalModelScenario(scenario_id='foundatio...rameter='model_name', prediction_url_suffix=None)]
- model_computed_fields = {}
- model_config = {'arbitrary_types_allowed': True, 'protected_namespaces': ()}
- 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)}
- 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: 'Model') -> 'Model'
- Returns a shallow copy of the model.
- __deepcopy__(self: 'Model', memo: 'dict[int, Any] | None' = None) -> 'Model'
- 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.
- __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_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: 'Model', *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'typing.Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Model'
- Returns a copy of the model.
!!! warning "Deprecated"
This method is now deprecated; use `model_copy` instead.
If you need `include` or `exclude`, use:
```py
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, exclude: 'IncEx' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False) -> 'typing.Dict[str, Any]'
- json(self, *, include: 'IncEx' = None, exclude: 'IncEx' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, encoder: 'typing.Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str'
- model_copy(self: 'Model', *, update: 'dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Model'
- Usage docs: https://docs.pydantic.dev/2.7/concepts/serialization/#model_copy
Returns a copy of the model.
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, exclude: 'IncEx' = None, context: 'dict[str, Any] | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, serialize_as_any: 'bool' = False) -> 'dict[str, Any]'
- Usage docs: https://docs.pydantic.dev/2.7/concepts/serialization/#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].
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, exclude: 'IncEx' = None, context: 'dict[str, Any] | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, serialize_as_any: 'bool' = False) -> 'str'
- Usage docs: https://docs.pydantic.dev/2.7/concepts/serialization/#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].
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
- Hook into generating the model's CoreSchema.
Args:
source: The class we are generating a schema for.
This will generally be the same as the `cls` argument if this is a classmethod.
handler: Call into Pydantic's internal JSON schema generation.
A callable that calls into Pydantic's internal CoreSchema generation logic.
Returns:
A `pydantic-core` `CoreSchema`.
- __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 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') -> 'Model' from gen_ai_hub.proxy.core.base.CombinedMeta
- from_orm(obj: 'Any') -> 'Model' from gen_ai_hub.proxy.core.base.CombinedMeta
- model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Model' 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: The set of field names accepted for the Model instance.
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 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.
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: 'dict[str, Any] | 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, from_attributes: 'bool | None' = None, context: 'dict[str, Any] | None' = None) -> 'Model' 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.
from_attributes: Whether to extract data from object attributes.
context: Additional context to pass to the validator.
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: 'dict[str, Any] | None' = None) -> 'Model' from gen_ai_hub.proxy.core.base.CombinedMeta
- Usage docs: https://docs.pydantic.dev/2.7/concepts/json/#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.
Returns:
The validated Pydantic model.
Raises:
ValueError: If `json_data` is not a JSON string.
- model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, context: 'dict[str, Any] | None' = None) -> 'Model' from gen_ai_hub.proxy.core.base.CombinedMeta
- Validate the given object contains string data against the Pydantic model.
Args:
obj: The object contains string data to validate.
strict: Whether to enforce types strictly.
context: Extra variables to pass to the validator.
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) -> 'Model' from gen_ai_hub.proxy.core.base.CombinedMeta
- parse_obj(obj: 'Any') -> 'Model' 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) -> 'Model' from gen_ai_hub.proxy.core.base.CombinedMeta
- schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'typing.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') -> 'Model' 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
| |