gen_ai_hub.proxy.core.base
index
/home/jenkins/agent/workspace/ation_generative-ai-hub-sdk_main/gen_ai_hub/proxy/core/base.py

 
Classes
       
abc.ABC(builtins.object)
BaseDeployment(pydantic.main.BaseModel, abc.ABC)
BaseProxyClient(abc.ABC, pydantic.main.BaseModel)
builtins.type(builtins.object)
InstanceCacheMeta
CombinedMeta(InstanceCacheMeta, pydantic._internal._model_construction.ModelMetaclass)
pydantic.main.BaseModel(builtins.object)
BaseDeployment(pydantic.main.BaseModel, abc.ABC)
BaseProxyClient(abc.ABC, pydantic.main.BaseModel)

 
class BaseDeployment(pydantic.main.BaseModel, abc.ABC)
    BaseDeployment() -> None
 

 
 
Method resolution order:
BaseDeployment
pydantic.main.BaseModel
abc.ABC
builtins.object

Methods defined here:
additional_request_body_kwargs(self) -> 'Dict[str, Any]'

Class methods defined here:
get_main_model_identification_kwargs() -> 'str' from pydantic._internal._model_construction.ModelMetaclass
get_model_identification_kwargs() -> 'Tuple[str]' from pydantic._internal._model_construction.ModelMetaclass

Readonly properties defined here:
prediction_url

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

Data and other attributes defined here:
__abstractmethods__ = frozenset({'additional_request_body_kwargs', 'get_model_identification_kwargs', 'prediction_url'})
__annotations__ = {}
__class_vars__ = set()
__private_attributes__ = {}
__pydantic_complete__ = True
__pydantic_core_schema__ = {'cls': <class 'gen_ai_hub.proxy.core.base.BaseDeployment'>, 'config': {'title': 'BaseDeployment'}, 'custom_init': False, 'metadata': {'pydantic.internal.needs_apply_discriminated_union': False, 'pydantic_js_annotation_functions': [], 'pydantic_js_functions': [functools.partial(<function modify_model_json_sc...ass 'gen_ai_hub.proxy.core.base.BaseDeployment'>), <bound method BaseModel.__get_pydantic_json_sche...ass 'gen_ai_hub.proxy.core.base.BaseDeployment'>>]}, 'ref': 'gen_ai_hub.proxy.core.base.BaseDeployment:140582002584400', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {}, 'model_name': 'BaseDeployment', 'type': 'model-fields'}, 'type': 'model'}
__pydantic_custom_init__ = False
__pydantic_decorators__ = DecoratorInfos(validators={}, field_validators={...zers={}, model_validators={}, computed_fields={})
__pydantic_generic_metadata__ = {'args': (), 'origin': None, 'parameters': ()}
__pydantic_parent_namespace__ = {'ABC': <pydantic._internal._model_construction._PydanticWeakRef object>, 'Any': <pydantic._internal._model_construction._PydanticWeakRef object>, 'BaseModel': <pydantic._internal._model_construction._PydanticWeakRef object>, 'ConfigDict': <pydantic._internal._model_construction._PydanticWeakRef object>, 'Dict': <pydantic._internal._model_construction._PydanticWeakRef object>, 'ModelMetaclass': <pydantic._internal._model_construction._PydanticWeakRef object>, 'Tuple': <pydantic._internal._model_construction._PydanticWeakRef object>, 'Type': <pydantic._internal._model_construction._PydanticWeakRef object>, '__builtins__': {'ArithmeticError': <class 'ArithmeticError'>, 'AssertionError': <class 'AssertionError'>, 'AttributeError': <class 'AttributeError'>, 'BaseException': <class 'BaseException'>, 'BlockingIOError': <class 'BlockingIOError'>, 'BrokenPipeError': <class 'BrokenPipeError'>, 'BufferError': <class 'BufferError'>, 'BytesWarning': <class 'BytesWarning'>, 'ChildProcessError': <class 'ChildProcessError'>, 'ConnectionAbortedError': <class 'ConnectionAbortedError'>, ...}, '__cached__': '/home/jenkins/agent/workspace/ation_generative-a...i_hub/proxy/core/__pycache__/base.cpython-310.pyc', ...}
__pydantic_post_init__ = None
__pydantic_serializer__ = SchemaSerializer(serializer=Model( ModelSeri...name: "BaseDeployment", }, ), definitions=[])
__pydantic_validator__ = SchemaValidator(title="BaseDeployment", validato...name: "BaseDeployment", }, ), definitions=[])
__signature__ = <Signature () -> None>
model_computed_fields = {}
model_config = {'protected_namespaces': ()}
model_fields = {}

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.6/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, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, round_trip: 'bool' = False, warnings: 'bool' = True) -> 'dict[str, Any]'
Usage docs: https://docs.pydantic.dev/2.6/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 list of fields to include in the output.
    exclude: A list of fields to exclude from the output.
    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: Whether to log warnings when invalid fields are encountered.
 
Returns:
    A dictionary representation of the model.
model_dump_json(self, *, indent: 'int | None' = None, include: 'IncEx' = None, exclude: 'IncEx' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, round_trip: 'bool' = False, warnings: 'bool' = True) -> 'str'
Usage docs: https://docs.pydantic.dev/2.6/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.
    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: Whether to log warnings when invalid fields are encountered.
 
Returns:
    A JSON string representation of the model.
model_post_init(self, _BaseModel__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__(_BaseModel__source: 'type[BaseModel]', _BaseModel__handler: 'GetCoreSchemaHandler') -> 'CoreSchema' from pydantic._internal._model_construction.ModelMetaclass
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__(_BaseModel__core_schema: 'CoreSchema', _BaseModel__handler: 'GetJsonSchemaHandler') -> 'JsonSchemaValue' from pydantic._internal._model_construction.ModelMetaclass
Hook into generating the model's JSON schema.
 
Args:
    __core_schema: A `pydantic-core` CoreSchema.
        You can ignore this argument and call the handler with a new CoreSchema,
        wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),
        or just call the handler with the original schema.
    __handler: Call into Pydantic's internal JSON schema generation.
        This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema
        generation fails.
        Since this gets called by `BaseModel.model_json_schema` you can override the
        `schema_generator` argument to that function to change JSON schema generation globally
        for a type.
 
Returns:
    A JSON schema, as a Python object.
__pydantic_init_subclass__(**kwargs: 'Any') -> 'None' from pydantic._internal._model_construction.ModelMetaclass
This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass`
only after the class is actually fully initialized. In particular, attributes like `model_fields` will
be present when this is called.
 
This is necessary because `__init_subclass__` will always be called by `type.__new__`,
and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that
`type.__new__` was called in such a manner that the class would already be sufficiently initialized.
 
This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely,
any kwargs passed to the class definition that aren't used internally by pydantic.
 
Args:
    **kwargs: Any keyword arguments passed to the class definition that aren't used internally
        by pydantic.
construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Model' from pydantic._internal._model_construction.ModelMetaclass
from_orm(obj: 'Any') -> 'Model' from pydantic._internal._model_construction.ModelMetaclass
model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Model' 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.
Behaves as if `Config.extra = 'allow'` was set since it adds all passed values
 
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 pydantic._internal._model_construction.ModelMetaclass
Generates a JSON schema for a model class.
 
Args:
    by_alias: Whether to use attribute aliases or not.
    ref_template: The reference template.
    schema_generator: To override the logic used to generate the JSON schema, as a subclass of
        `GenerateJsonSchema` with your desired modifications
    mode: The mode in which to generate the schema.
 
Returns:
    The JSON schema for the given model class.
model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str' from pydantic._internal._model_construction.ModelMetaclass
Compute the class name for parametrizations of generic classes.
 
This method can be overridden to achieve a custom naming scheme for generic BaseModels.
 
Args:
    params: Tuple of types of the class. Given a generic class
        `Model` with 2 type variables and a concrete model `Model[str, int]`,
        the value `(str, int)` would be passed to `params`.
 
Returns:
    String representing the new class where `params` are passed to `cls` as type variables.
 
Raises:
    TypeError: Raised when trying to generate concrete names for non-generic models.
model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'dict[str, Any] | None' = None) -> 'bool | None' from pydantic._internal._model_construction.ModelMetaclass
Try to rebuild the pydantic-core schema for the model.
 
This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
the initial attempt to build the schema, and automatic rebuilding fails.
 
Args:
    force: Whether to force the rebuilding of the model schema, defaults to `False`.
    raise_errors: Whether to raise errors, defaults to `True`.
    _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
    _types_namespace: The types namespace, defaults to `None`.
 
Returns:
    Returns `None` if the schema is already "complete" and rebuilding was not required.
    If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
model_validate(obj: 'Any', *, strict: 'bool | None' = None, from_attributes: 'bool | None' = None, context: 'dict[str, Any] | None' = None) -> 'Model' from pydantic._internal._model_construction.ModelMetaclass
Validate a pydantic model instance.
 
Args:
    obj: The object to validate.
    strict: Whether to enforce types strictly.
    from_attributes: Whether to extract data from object attributes.
    context: Additional context to pass to the validator.
 
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 pydantic._internal._model_construction.ModelMetaclass
Usage docs: https://docs.pydantic.dev/2.6/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 pydantic._internal._model_construction.ModelMetaclass
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 pydantic._internal._model_construction.ModelMetaclass
parse_obj(obj: 'Any') -> 'Model' 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) -> 'Model' from pydantic._internal._model_construction.ModelMetaclass
schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'typing.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') -> 'Model' 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

 
class BaseProxyClient(abc.ABC, pydantic.main.BaseModel)
    BaseProxyClient() -&gt; None
 

 
 
Method resolution order:
BaseProxyClient
abc.ABC
pydantic.main.BaseModel
builtins.object

Methods defined here:
select_deployment(self, **kwargs) -> 'BaseDeployment'

Class methods defined here:
refresh_instance_cache() from CombinedMeta
Refresh the cache of instances.

Readonly properties defined here:
deployment_class
deployments
request_header

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

Data and other attributes defined here:
__abstractmethods__ = frozenset({'deployment_class', 'deployments', 'request_header', 'select_deployment'})
__annotations__ = {}
__class_vars__ = set()
__private_attributes__ = {}
__pydantic_complete__ = True
__pydantic_core_schema__ = {'cls': <class 'gen_ai_hub.proxy.core.base.BaseProxyClient'>, 'config': {'title': 'BaseProxyClient'}, 'custom_init': False, 'metadata': {'pydantic.internal.needs_apply_discriminated_union': False, 'pydantic_js_annotation_functions': [], 'pydantic_js_functions': [functools.partial(<function modify_model_json_sc...ss 'gen_ai_hub.proxy.core.base.BaseProxyClient'>), <bound method BaseModel.__get_pydantic_json_sche...ss 'gen_ai_hub.proxy.core.base.BaseProxyClient'>>]}, 'ref': 'gen_ai_hub.proxy.core.base.BaseProxyClient:140582000323184', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {}, 'model_name': 'BaseProxyClient', 'type': 'model-fields'}, 'type': 'model'}
__pydantic_custom_init__ = False
__pydantic_decorators__ = DecoratorInfos(validators={}, field_validators={...zers={}, model_validators={}, computed_fields={})
__pydantic_generic_metadata__ = {'args': (), 'origin': None, 'parameters': ()}
__pydantic_parent_namespace__ = {'ABC': <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>, 'CombinedMeta': <pydantic._internal._model_construction._PydanticWeakRef object>, 'ConfigDict': <pydantic._internal._model_construction._PydanticWeakRef object>, 'Dict': <pydantic._internal._model_construction._PydanticWeakRef object>, 'InstanceCacheMeta': <pydantic._internal._model_construction._PydanticWeakRef object>, 'ModelMetaclass': <pydantic._internal._model_construction._PydanticWeakRef object>, 'Tuple': <pydantic._internal._model_construction._PydanticWeakRef object>, ...}
__pydantic_post_init__ = None
__pydantic_serializer__ = SchemaSerializer(serializer=Model( ModelSeri...ame: "BaseProxyClient", }, ), definitions=[])
__pydantic_validator__ = SchemaValidator(title="BaseProxyClient", validat...ame: "BaseProxyClient", }, ), definitions=[])
__signature__ = <Signature () -> None>
model_computed_fields = {}
model_config = {'protected_namespaces': ()}
model_fields = {}

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.6/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, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, round_trip: 'bool' = False, warnings: 'bool' = True) -> 'dict[str, Any]'
Usage docs: https://docs.pydantic.dev/2.6/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 list of fields to include in the output.
    exclude: A list of fields to exclude from the output.
    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: Whether to log warnings when invalid fields are encountered.
 
Returns:
    A dictionary representation of the model.
model_dump_json(self, *, indent: 'int | None' = None, include: 'IncEx' = None, exclude: 'IncEx' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, round_trip: 'bool' = False, warnings: 'bool' = True) -> 'str'
Usage docs: https://docs.pydantic.dev/2.6/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.
    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: Whether to log warnings when invalid fields are encountered.
 
Returns:
    A JSON string representation of the model.
model_post_init(self, _BaseModel__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 CombinedMeta
__get_pydantic_core_schema__(_BaseModel__source: 'type[BaseModel]', _BaseModel__handler: 'GetCoreSchemaHandler') -> 'CoreSchema' from 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__(_BaseModel__core_schema: 'CoreSchema', _BaseModel__handler: 'GetJsonSchemaHandler') -> 'JsonSchemaValue' from 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 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 CombinedMeta
from_orm(obj: 'Any') -> 'Model' from CombinedMeta
model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Model' from 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.
Behaves as if `Config.extra = 'allow'` was set since it adds all passed values
 
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 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 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 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 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 CombinedMeta
Usage docs: https://docs.pydantic.dev/2.6/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 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 CombinedMeta
parse_obj(obj: 'Any') -> 'Model' from CombinedMeta
parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Model' from CombinedMeta
schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'typing.Dict[str, Any]' from CombinedMeta
schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str' from CombinedMeta
update_forward_refs(**localns: 'Any') -> 'None' from CombinedMeta
validate(value: 'Any') -> 'Model' from 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

 
class CombinedMeta(InstanceCacheMeta, pydantic._internal._model_construction.ModelMetaclass)
    CombinedMeta(cls_name: 'str', bases: 'tuple[type[Any], ...]', namespace: 'dict[str, Any]', __pydantic_generic_metadata__: 'PydanticGenericMetadata | None' = None, __pydantic_reset_parent_namespace__: 'bool' = True, _create_model_module: 'str | None' = None, **kwargs: 'Any') -&gt; 'type'
 

 
 
Method resolution order:
CombinedMeta
InstanceCacheMeta
pydantic._internal._model_construction.ModelMetaclass
abc.ABCMeta
builtins.type
builtins.object

Data and other attributes defined here:
__annotations__ = {}

Methods inherited from InstanceCacheMeta:
__call__(cls, *args, **kwargs)
Call self as a function.
clear_cache(cls)
Clear the instance cache.

Methods inherited from pydantic._internal._model_construction.ModelMetaclass:
__dir__(self) -> 'list[str]'
Specialized __dir__ implementation for types.
__getattr__(self, item: 'str') -> 'Any'
This is necessary to keep attribute access working for class attribute access.
__instancecheck__(self, instance: 'Any') -> 'bool'
Avoid calling ABC _abc_subclasscheck unless we're pretty sure.
 
See #3829 and python/cpython#92810

Class methods inherited from pydantic._internal._model_construction.ModelMetaclass:
__prepare__(*args: 'Any', **kwargs: 'Any') -> 'dict[str, object]' from builtins.type
__prepare__() -> dict
used to create the namespace for the class statement

Static methods inherited from pydantic._internal._model_construction.ModelMetaclass:
__new__(mcs, cls_name: 'str', bases: 'tuple[type[Any], ...]', namespace: 'dict[str, Any]', __pydantic_generic_metadata__: 'PydanticGenericMetadata | None' = None, __pydantic_reset_parent_namespace__: 'bool' = True, _create_model_module: 'str | None' = None, **kwargs: 'Any') -> 'type'
Metaclass for creating Pydantic models.
 
Args:
    cls_name: The name of the class to be created.
    bases: The base classes of the class to be created.
    namespace: The attribute dictionary of the class to be created.
    __pydantic_generic_metadata__: Metadata for generic models.
    __pydantic_reset_parent_namespace__: Reset parent namespace.
    _create_model_module: The module of the class to be created, if created by `create_model`.
    **kwargs: Catch-all for any other keyword arguments.
 
Returns:
    The new class created by the metaclass.

Readonly properties inherited from pydantic._internal._model_construction.ModelMetaclass:
__fields__

Data and other attributes inherited from pydantic._internal._model_construction.ModelMetaclass:
__dataclass_transform__ = {'eq_default': True, 'field_specifiers': (<object object>,), 'frozen_default': False, 'kw_only_default': True, 'kwargs': {}, 'order_default': False}

Methods inherited from abc.ABCMeta:
__subclasscheck__(cls, subclass)
Override for issubclass(subclass, cls).
register(cls, subclass)
Register a virtual subclass of an ABC.
 
Returns the subclass, to allow usage as a class decorator.

Methods inherited from builtins.type:
__delattr__(self, name, /)
Implement delattr(self, name).
__getattribute__(self, name, /)
Return getattr(self, name).
__init__(self, /, *args, **kwargs)
Initialize self.  See help(type(self)) for accurate signature.
__or__(self, value, /)
Return self|value.
__repr__(self, /)
Return repr(self).
__ror__(self, value, /)
Return value|self.
__setattr__(self, name, value, /)
Implement setattr(self, name, value).
__sizeof__(self, /)
Return memory consumption of the type object.
__subclasses__(self, /)
Return a list of immediate subclasses.
mro(self, /)
Return a type's method resolution order.

Data descriptors inherited from builtins.type:
__abstractmethods__
__dict__
__text_signature__

Data and other attributes inherited from builtins.type:
__base__ = <class 'gen_ai_hub.proxy.core.base.InstanceCacheMeta'>
__bases__ = (<class 'gen_ai_hub.proxy.core.base.InstanceCacheMeta'>, <class 'pydantic._internal._model_construction.ModelMetaclass'>)
__basicsize__ = 888
__dictoffset__ = 264
__flags__ = 2148029952
__itemsize__ = 40
__mro__ = (<class 'gen_ai_hub.proxy.core.base.CombinedMeta'>, <class 'gen_ai_hub.proxy.core.base.InstanceCacheMeta'>, <class 'pydantic._internal._model_construction.ModelMetaclass'>, <class 'abc.ABCMeta'>, <class 'type'>, <class 'object'>)
__weakrefoffset__ = 368

 
class InstanceCacheMeta(builtins.type)
    
Method resolution order:
InstanceCacheMeta
builtins.type
builtins.object

Methods defined here:
__call__(cls, *args, **kwargs)
Call self as a function.
clear_cache(cls)
Clear the instance cache.

Data and other attributes defined here:
__annotations__ = {}

Methods inherited from builtins.type:
__delattr__(self, name, /)
Implement delattr(self, name).
__dir__(self, /)
Specialized __dir__ implementation for types.
__getattribute__(self, name, /)
Return getattr(self, name).
__init__(self, /, *args, **kwargs)
Initialize self.  See help(type(self)) for accurate signature.
__instancecheck__(self, instance, /)
Check if an object is an instance.
__or__(self, value, /)
Return self|value.
__repr__(self, /)
Return repr(self).
__ror__(self, value, /)
Return value|self.
__setattr__(self, name, value, /)
Implement setattr(self, name, value).
__sizeof__(self, /)
Return memory consumption of the type object.
__subclasscheck__(self, subclass, /)
Check if a class is a subclass.
__subclasses__(self, /)
Return a list of immediate subclasses.
mro(self, /)
Return a type's method resolution order.

Class methods inherited from builtins.type:
__prepare__(...) from builtins.type
__prepare__() -> dict
used to create the namespace for the class statement

Static methods inherited from builtins.type:
__new__(*args, **kwargs) from builtins.type
Create and return a new object.  See help(type) for accurate signature.

Data descriptors inherited from builtins.type:
__abstractmethods__
__dict__
__text_signature__

Data and other attributes inherited from builtins.type:
__base__ = <class 'type'>
type(object) -> the object's type
type(name, bases, dict, **kwds) -> a new type
__bases__ = (<class 'type'>,)
__basicsize__ = 888
__dictoffset__ = 264
__flags__ = 2148029952
__itemsize__ = 40
__mro__ = (<class 'gen_ai_hub.proxy.core.base.InstanceCacheMeta'>, <class 'type'>, <class 'object'>)
__weakrefoffset__ = 368

 
Data
        Any = typing.Any
Dict = typing.Dict
Tuple = typing.Tuple
Type = typing.Type
annotations = _Feature((3, 7, 0, 'beta', 1), (3, 11, 0, 'alpha', 0), 16777216)