Data Masking Module Configuration Models

Classes
		builtins.str(builtins.object) DataMaskingProviderName(builtins.str, enum.Enum) MaskingMethod(builtins.str, enum.Enum) ProfileEntity(builtins.str, enum.Enum) enum.Enum(builtins.object) DataMaskingProviderName(builtins.str, enum.Enum) MaskingMethod(builtins.str, enum.Enum) ProfileEntity(builtins.str, enum.Enum) gen_ai_hub.orchestration_v2.models.base.ABCBaseModel(pydantic.main.BaseModel, abc.ABC) DPICustomEntity DPIMethodConstant DPIMethodFabricatedData DPIStandardEntity MaskGroundingInput MaskingModuleConfig MaskingProviderConfig   class DPICustomEntity(gen_ai_hub.orchestration_v2.models.base.ABCBaseModel)     DPICustomEntity(*, regex: str, replacement_strategy: gen_ai_hub.orchestration_v2.models.data_masking.DPIMethodConstant) -&gt; None   regex: Regular expression to match the entity replacement_strategy: Replacement strategy to be used for the entity     Method resolution order: DPICustomEntity gen_ai_hub.orchestration_v2.models.base.ABCBaseModel pydantic.main.BaseModel abc.ABC builtins.object Data and other attributes defined here: __abstractmethods__ = frozenset() __annotations__ = {'regex': <class 'str'>, 'replacement_strategy': <class 'gen_ai_hub.orchestration_v2.models.data_masking.DPIMethodConstant'>} __class_vars__ = set() __private_attributes__ = {} __pydantic_complete__ = True __pydantic_computed_fields__ = {} __pydantic_core_schema__ = {'cls': <class 'gen_ai_hub.orchestration_v2.models.data_masking.DPICustomEntity'>, 'config': {'extra_fields_behavior': 'forbid', 'title': 'DPICustomEntity'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...tration_v2.models.data_masking.DPICustomEntity'>>]}, 'ref': 'gen_ai_hub.orchestration_v2.models.data_masking.DPICustomEntity:139913247039456', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'regex': {'metadata': {}, 'schema': {'type': 'str'}, 'type': 'model-field'}, 'replacement_strategy': {'metadata': {}, 'schema': {'cls': <class 'gen_ai_hub.orchestration_v2.models.data_masking.DPIMethodConstant'>, 'config': {'extra_fields_behavior': 'forbid', 'title': 'DPIMethodConstant'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [...]}, 'ref': 'gen_ai_hub.orchestration_v2.models.data_masking.DPIMethodConstant:139913247036480', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {...}, 'model_name': 'DPIMethodConstant', 'type': 'model-fields'}, 'type': 'model'}, 'type': 'model-field'}}, 'model_name': 'DPICustomEntity', 'type': 'model-fields'}, 'type': 'model'} __pydantic_custom_init__ = False __pydantic_decorators__ = DecoratorInfos(validators={}, field_validators={...zers={}, model_validators={}, computed_fields={}) __pydantic_fields__ = {'regex': FieldInfo(annotation=str, required=True), 'replacement_strategy': FieldInfo(annotation=DPIMethodConstant, required=True)} __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'parameters': ()} __pydantic_parent_namespace__ = None __pydantic_post_init__ = None __pydantic_serializer__ = SchemaSerializer(serializer=Model( ModelSeri...ame: "DPICustomEntity", }, ), definitions=[]) __pydantic_setattr_handlers__ = {} __pydantic_validator__ = SchemaValidator(title="DPICustomEntity", validat...y", }, ), definitions=[], cache_strings=True) __signature__ = <Signature (*, regex: str, replacement_strategy:...2.models.data_masking.DPIMethodConstant) -> None> model_config = {'extra': 'forbid', 'frozen': False} Methods inherited from gen_ai_hub.orchestration_v2.models.base.ABCBaseModel: model_dump(self, **kwargs) Dumps the model to a dictionary with default settings. Data descriptors inherited from gen_ai_hub.orchestration_v2.models.base.ABCBaseModel: __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_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 = {'regex': FieldInfo(annotation=str, required=True), 'replacement_strategy': FieldInfo(annotation=DPIMethodConstant, required=True)}   class DPIMethodConstant(gen_ai_hub.orchestration_v2.models.base.ABCBaseModel)     DPIMethodConstant(*, method: str = 'constant', value: str) -&gt; None   Replaces the entity with the specified value followed by an incrementing number     Method resolution order: DPIMethodConstant gen_ai_hub.orchestration_v2.models.base.ABCBaseModel pydantic.main.BaseModel abc.ABC builtins.object Data and other attributes defined here: __abstractmethods__ = frozenset() __annotations__ = {'method': <class 'str'>, 'value': <class 'str'>} __class_vars__ = set() __private_attributes__ = {} __pydantic_complete__ = True __pydantic_computed_fields__ = {} __pydantic_core_schema__ = {'cls': <class 'gen_ai_hub.orchestration_v2.models.data_masking.DPIMethodConstant'>, 'config': {'extra_fields_behavior': 'forbid', 'title': 'DPIMethodConstant'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...ation_v2.models.data_masking.DPIMethodConstant'>>]}, 'ref': 'gen_ai_hub.orchestration_v2.models.data_masking.DPIMethodConstant:139913247036480', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'method': {'metadata': {}, 'schema': {'default': 'constant', 'schema': {'type': 'str'}, 'type': 'default'}, 'type': 'model-field'}, 'value': {'metadata': {}, 'schema': {'type': 'str'}, 'type': 'model-field'}}, 'model_name': 'DPIMethodConstant', 'type': 'model-fields'}, 'type': 'model'} __pydantic_custom_init__ = False __pydantic_decorators__ = DecoratorInfos(validators={}, field_validators={...zers={}, model_validators={}, computed_fields={}) __pydantic_fields__ = {'method': FieldInfo(annotation=str, required=False, default='constant'), 'value': 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...e: "DPIMethodConstant", }, ), definitions=[]) __pydantic_setattr_handlers__ = {} __pydantic_validator__ = SchemaValidator(title="DPIMethodConstant", valid...t", }, ), definitions=[], cache_strings=True) __signature__ = <Signature (*, method: str = 'constant', value: str) -> None> model_config = {'extra': 'forbid', 'frozen': False} Methods inherited from gen_ai_hub.orchestration_v2.models.base.ABCBaseModel: model_dump(self, **kwargs) Dumps the model to a dictionary with default settings. Data descriptors inherited from gen_ai_hub.orchestration_v2.models.base.ABCBaseModel: __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_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 = {'method': FieldInfo(annotation=str, required=False, default='constant'), 'value': FieldInfo(annotation=str, required=True)}   class DPIMethodFabricatedData(gen_ai_hub.orchestration_v2.models.base.ABCBaseModel)     DPIMethodFabricatedData(*, method: str = 'fabricated_data') -&gt; None   Replaces the entity with a randomly generated value appropriate to its type.     Method resolution order: DPIMethodFabricatedData gen_ai_hub.orchestration_v2.models.base.ABCBaseModel pydantic.main.BaseModel abc.ABC builtins.object Data and other attributes defined here: __abstractmethods__ = frozenset() __annotations__ = {'method': <class 'str'>} __class_vars__ = set() __private_attributes__ = {} __pydantic_complete__ = True __pydantic_computed_fields__ = {} __pydantic_core_schema__ = {'cls': <class 'gen_ai_hub.orchestration_v2.models.data_masking.DPIMethodFabricatedData'>, 'config': {'extra_fields_behavior': 'forbid', 'title': 'DPIMethodFabricatedData'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...v2.models.data_masking.DPIMethodFabricatedData'>>]}, 'ref': 'gen_ai_hub.orchestration_v2.models.data_masking.DPIMethodFabricatedData:139913247038448', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'method': {'metadata': {}, 'schema': {'default': 'fabricated_data', 'schema': {'type': 'str'}, 'type': 'default'}, 'type': 'model-field'}}, 'model_name': 'DPIMethodFabricatedData', 'type': 'model-fields'}, 'type': 'model'} __pydantic_custom_init__ = False __pydantic_decorators__ = DecoratorInfos(validators={}, field_validators={...zers={}, model_validators={}, computed_fields={}) __pydantic_fields__ = {'method': FieldInfo(annotation=str, required=False, default='fabricated_data')} __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'parameters': ()} __pydantic_parent_namespace__ = None __pydantic_post_init__ = None __pydantic_serializer__ = SchemaSerializer(serializer=Model( ModelSeri...IMethodFabricatedData", }, ), definitions=[]) __pydantic_setattr_handlers__ = {} __pydantic_validator__ = SchemaValidator(title="DPIMethodFabricatedData",...a", }, ), definitions=[], cache_strings=True) __signature__ = <Signature (*, method: str = 'fabricated_data') -> None> model_config = {'extra': 'forbid', 'frozen': False} Methods inherited from gen_ai_hub.orchestration_v2.models.base.ABCBaseModel: model_dump(self, **kwargs) Dumps the model to a dictionary with default settings. Data descriptors inherited from gen_ai_hub.orchestration_v2.models.base.ABCBaseModel: __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_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 = {'method': FieldInfo(annotation=str, required=False, default='fabricated_data')}   class DPIStandardEntity(gen_ai_hub.orchestration_v2.models.base.ABCBaseModel)     DPIStandardEntity(*, type: gen_ai_hub.orchestration_v2.models.data_masking.ProfileEntity, replacement_strategy: Union[gen_ai_hub.orchestration_v2.models.data_masking.DPIMethodConstant, gen_ai_hub.orchestration_v2.models.data_masking.DPIMethodFabricatedData, NoneType] = None) -&gt; None   type: Standard entity type to be masked replacement_strategy: Replacement strategy to be used for the entity     Method resolution order: DPIStandardEntity gen_ai_hub.orchestration_v2.models.base.ABCBaseModel pydantic.main.BaseModel abc.ABC builtins.object Data and other attributes defined here: __abstractmethods__ = frozenset() __annotations__ = {'replacement_strategy': typing.Union[gen_ai_hub.orchestration_v2.models....s.data_masking.DPIMethodFabricatedData, NoneType], 'type_': <enum 'ProfileEntity'>} __class_vars__ = set() __private_attributes__ = {} __pydantic_complete__ = True __pydantic_computed_fields__ = {} __pydantic_core_schema__ = {'cls': <class 'gen_ai_hub.orchestration_v2.models.data_masking.DPIStandardEntity'>, 'config': {'extra_fields_behavior': 'forbid', 'title': 'DPIStandardEntity'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...ation_v2.models.data_masking.DPIStandardEntity'>>]}, 'ref': 'gen_ai_hub.orchestration_v2.models.data_masking.DPIStandardEntity:139913247040480', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'replacement_strategy': {'metadata': {}, 'schema': {'default': None, 'schema': {'schema': {...}, 'type': 'nullable'}, 'type': 'default'}, 'type': 'model-field'}, 'type_': {'metadata': {}, 'schema': {'cls': <enum 'ProfileEntity'>, 'members': [<ProfileEntity.PERSON: 'profile-person'>, <ProfileEntity.ORG: 'profile-org'>, <ProfileEntity.UNIVERSITY: 'profile-university'>, <ProfileEntity.LOCATION: 'profile-location'>, <ProfileEntity.EMAIL: 'profile-email'>, <ProfileEntity.PHONE: 'profile-phone'>, <ProfileEntity.ADDRESS: 'profile-address'>, <ProfileEntity.SAP_IDS_INTERNAL: 'profile-sapids-internal'>, <ProfileEntity.SAP_IDS_PUBLIC: 'profile-sapids-public'>, <ProfileEntity.URL: 'profile-url'>, <ProfileEntity.USERNAME_PASSWORD: 'profile-username-password'>, <ProfileEntity.NATIONAL_ID: 'profile-nationalid'>, <ProfileEntity.IBAN: 'profile-iban'>, <ProfileEntity.SSN: 'profile-ssn'>, <ProfileEntity.CREDIT_CARD_NUMBER: 'profile-credit-card-number'>, <ProfileEntity.PASSPORT: 'profile-passport'>, <ProfileEntity.DRIVING_LICENSE: 'profile-driverlicense'>, <ProfileEntity.NATIONALITY: 'profile-nationality'>, <ProfileEntity.RELIGIOUS_GROUP: 'profile-religious-group'>, <ProfileEntity.POLITICAL_GROUP: 'profile-political-group'>, ...], 'metadata': {'pydantic_js_functions': [...]}, 'ref': 'gen_ai_hub.orchestration_v2.models.data_masking.ProfileEntity:139913247035472', 'sub_type': 'str', 'type': 'enum'}, 'serialization_alias': 'type', 'type': 'model-field', 'validation_alias': 'type'}}, 'model_name': 'DPIStandardEntity', 'type': 'model-fields'}, 'type': 'model'} __pydantic_custom_init__ = False __pydantic_decorators__ = DecoratorInfos(validators={}, field_validators={...zers={}, model_validators={}, computed_fields={}) __pydantic_fields__ = {'replacement_strategy': FieldInfo(annotation=Union[DPIMethodConstant, DP...tedData, NoneType], required=False, default=None), 'type_': FieldInfo(annotation=ProfileEntity, required=True, alias='type', alias_priority=2)} __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'parameters': ()} __pydantic_parent_namespace__ = None __pydantic_post_init__ = None __pydantic_serializer__ = SchemaSerializer(serializer=Model( ModelSeri...e: "DPIStandardEntity", }, ), definitions=[]) __pydantic_setattr_handlers__ = {} __pydantic_validator__ = SchemaValidator(title="DPIStandardEntity", valid...y", }, ), definitions=[], cache_strings=True) __signature__ = <Signature (*, type: gen_ai_hub.orchestration_v2...IMethodFabricatedData, NoneType] = None) -> None> model_config = {'extra': 'forbid', 'frozen': False} Methods inherited from gen_ai_hub.orchestration_v2.models.base.ABCBaseModel: model_dump(self, **kwargs) Dumps the model to a dictionary with default settings. Data descriptors inherited from gen_ai_hub.orchestration_v2.models.base.ABCBaseModel: __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_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 = {'replacement_strategy': FieldInfo(annotation=Union[DPIMethodConstant, DP...tedData, NoneType], required=False, default=None), 'type_': FieldInfo(annotation=ProfileEntity, required=True, alias='type', alias_priority=2)}   class DataMaskingProviderName(builtins.str, enum.Enum)     DataMaskingProviderName(value, names=None, *, module=None, qualname=None, type=None, start=1)   Enumerates the available data masking providers.   This enum defines the supported providers for masking sensitive data in the LLM module.   Values: SAP_DATA_PRIVACY_INTEGRATION: Refers to the SAP Data Privacy Integration service, which offers anonymization and pseudonymization capabilities for sensitive data.     Method resolution order: DataMaskingProviderName builtins.str enum.Enum builtins.object Data and other attributes defined here: SAP_DATA_PRIVACY_INTEGRATION = <DataMaskingProviderName.SAP_DATA_PRIVACY_INTEGRATION: 'sap_data_privacy_integration'> 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.   class MaskGroundingInput(gen_ai_hub.orchestration_v2.models.base.ABCBaseModel)     MaskGroundingInput(*, enabled: bool = False) -&gt; None   Controls whether the input to the grounding module will be masked with the configuration supplied in the masking module     Method resolution order: MaskGroundingInput gen_ai_hub.orchestration_v2.models.base.ABCBaseModel pydantic.main.BaseModel abc.ABC builtins.object Data and other attributes defined here: __abstractmethods__ = frozenset() __annotations__ = {'enabled': <class 'bool'>} __class_vars__ = set() __private_attributes__ = {} __pydantic_complete__ = True __pydantic_computed_fields__ = {} __pydantic_core_schema__ = {'cls': <class 'gen_ai_hub.orchestration_v2.models.data_masking.MaskGroundingInput'>, 'config': {'extra_fields_behavior': 'forbid', 'title': 'MaskGroundingInput'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...tion_v2.models.data_masking.MaskGroundingInput'>>]}, 'ref': 'gen_ai_hub.orchestration_v2.models.data_masking.MaskGroundingInput:139913247043536', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'enabled': {'metadata': {}, 'schema': {'default': False, 'schema': {'type': 'bool'}, 'type': 'default'}, 'type': 'model-field'}}, 'model_name': 'MaskGroundingInput', 'type': 'model-fields'}, 'type': 'model'} __pydantic_custom_init__ = False __pydantic_decorators__ = DecoratorInfos(validators={}, field_validators={...zers={}, model_validators={}, computed_fields={}) __pydantic_fields__ = {'enabled': FieldInfo(annotation=bool, required=False, default=False)} __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'parameters': ()} __pydantic_parent_namespace__ = None __pydantic_post_init__ = None __pydantic_serializer__ = SchemaSerializer(serializer=Model( ModelSeri...: "MaskGroundingInput", }, ), definitions=[]) __pydantic_setattr_handlers__ = {} __pydantic_validator__ = SchemaValidator(title="MaskGroundingInput", vali...t", }, ), definitions=[], cache_strings=True) __signature__ = <Signature (*, enabled: bool = False) -> None> model_config = {'extra': 'forbid', 'frozen': False} Methods inherited from gen_ai_hub.orchestration_v2.models.base.ABCBaseModel: model_dump(self, **kwargs) Dumps the model to a dictionary with default settings. Data descriptors inherited from gen_ai_hub.orchestration_v2.models.base.ABCBaseModel: __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_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 = {'enabled': FieldInfo(annotation=bool, required=False, default=False)}   class MaskingMethod(builtins.str, enum.Enum)     MaskingMethod(value, names=None, *, module=None, qualname=None, type=None, start=1)   Enumerates the supported masking methods.   This enum defines the two main methods for masking sensitive information: anonymization and pseudonymization. Anonymization irreversibly removes sensitive data, while pseudonymization allows the original data to be recovered.   Values:     ANONYMIZATION: Irreversibly replaces sensitive data with placeholders (e.g., MASKED_ENTITY).       PSEUDONYMIZATION: Replaces sensitive data with reversible placeholders (e.g., MASKED_ENTITY_ID).     Method resolution order: MaskingMethod builtins.str enum.Enum builtins.object Data and other attributes defined here: ANONYMIZATION = <MaskingMethod.ANONYMIZATION: 'anonymization'> PSEUDONYMIZATION = <MaskingMethod.PSEUDONYMIZATION: 'pseudonymization'> 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.   class MaskingModuleConfig(gen_ai_hub.orchestration_v2.models.base.ABCBaseModel)     MaskingModuleConfig(*, providers: Annotated[Optional[List[gen_ai_hub.orchestration_v2.models.data_masking.MaskingProviderConfig]], MinLen(min_length=1)] = None, masking_providers: Annotated[Optional[List[gen_ai_hub.orchestration_v2.models.data_masking.MaskingProviderConfig]], MinLen(min_length=1)] = None) -&gt; None   Configuration for the data masking module.   Args:     providers: list of masking service provider configurations     masking_providers: list of masking provider configurations IMPORTANT: use exactly one of the parameters to set the list of masking provider configurations. DEPRECATED: parameter 'masking_providers' will be removed Sept 15, 2026. Use 'providers' instead.     Method resolution order: MaskingModuleConfig gen_ai_hub.orchestration_v2.models.base.ABCBaseModel pydantic.main.BaseModel abc.ABC builtins.object Methods defined here: enforce_exactly_one_provider_list(self) Data and other attributes defined here: __abstractmethods__ = frozenset() __annotations__ = {'masking_providers': typing.Optional[typing.List[gen_ai_hub.orchestration_v2.models.data_masking.MaskingProviderConfig]], 'providers': typing.Optional[typing.List[gen_ai_hub.orchestration_v2.models.data_masking.MaskingProviderConfig]]} __class_vars__ = set() __private_attributes__ = {} __pydantic_complete__ = True __pydantic_computed_fields__ = {} __pydantic_core_schema__ = {'definitions': [{'cls': <class 'gen_ai_hub.orchestration_v2.models.data_masking.MaskingProviderConfig'>, 'config': {'extra_fields_behavior': 'forbid', 'title': 'MaskingProviderConfig'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...n_v2.models.data_masking.MaskingProviderConfig'>>]}, 'ref': 'gen_ai_hub.orchestration_v2.models.data_masking.MaskingProviderConfig:139913247044544', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'allowlist': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'entities': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'mask_grounding_input': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'method': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'type_': {'metadata': {}, 'schema': {...}, 'serialization_alias': 'type', 'type': 'model-field', 'validation_alias': 'type'}}, 'model_name': 'MaskingProviderConfig', 'type': 'model-fields'}, 'type': 'model'}], 'schema': {'function': {'function': <function MaskingModuleConfig.enforce_exactly_one_provider_list>, 'type': 'no-info'}, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...ion_v2.models.data_masking.MaskingModuleConfig'>>]}, 'ref': 'gen_ai_hub.orchestration_v2.models.data_masking.MaskingModuleConfig:139913247045504', 'schema': {'cls': <class 'gen_ai_hub.orchestration_v2.models.data_masking.MaskingModuleConfig'>, 'config': {'extra_fields_behavior': 'forbid', 'title': 'MaskingModuleConfig'}, 'custom_init': False, 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'masking_providers': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}, 'providers': {'metadata': {}, 'schema': {...}, 'type': 'model-field'}}, 'model_name': 'MaskingModuleConfig', 'type': 'model-fields'}, 'type': 'model'}, 'type': 'function-after'}, 'type': 'definitions'} __pydantic_custom_init__ = False __pydantic_decorators__ = DecoratorInfos(validators={}, field_validators={...ecoratorInfo(mode='after'))}, computed_fields={}) __pydantic_fields__ = {'masking_providers': FieldInfo(annotation=Union[List[MaskingProviderC...e, default=None, metadata=[MinLen(min_length=1)]), 'providers': FieldInfo(annotation=Union[List[MaskingProviderC...e, default=None, metadata=[MinLen(min_length=1)])} __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'parameters': ()} __pydantic_parent_namespace__ = None __pydantic_post_init__ = None __pydantic_serializer__ = SchemaSerializer(serializer=Model( ModelSeri...izer { schema_serializer: Py(0x7f40176e7e20) })]) __pydantic_setattr_handlers__ = {} __pydantic_validator__ = SchemaValidator(title="MaskingModuleConfig", val...ator: Py(0x7f40176e7d90) })], cache_strings=True) __signature__ = <Signature (*, providers: Annotated[Optional[Lis...rConfig]], MinLen(min_length=1)] = None) -> None> model_config = {'extra': 'forbid', 'frozen': False} Methods inherited from gen_ai_hub.orchestration_v2.models.base.ABCBaseModel: model_dump(self, **kwargs) Dumps the model to a dictionary with default settings. Data descriptors inherited from gen_ai_hub.orchestration_v2.models.base.ABCBaseModel: __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_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 = {'masking_providers': FieldInfo(annotation=Union[List[MaskingProviderC...e, default=None, metadata=[MinLen(min_length=1)]), 'providers': FieldInfo(annotation=Union[List[MaskingProviderC...e, default=None, metadata=[MinLen(min_length=1)])}   class MaskingProviderConfig(gen_ai_hub.orchestration_v2.models.base.ABCBaseModel)     MaskingProviderConfig(*, type: gen_ai_hub.orchestration_v2.models.data_masking.DataMaskingProviderName = &lt;DataMaskingProviderName.SAP_DATA_PRIVACY_INTEGRATION: 'sap_data_privacy_integration'&gt;, method: gen_ai_hub.orchestration_v2.models.data_masking.MaskingMethod, entities: List[Union[gen_ai_hub.orchestration_v2.models.data_masking.DPIStandardEntity, gen_ai_hub.orchestration_v2.models.data_masking.DPICustomEntity]], allowlist: Optional[List[str]] = None, mask_grounding_input: Optional[gen_ai_hub.orchestration_v2.models.data_masking.MaskGroundingInput] = None) -&gt; None   SAP Data Privacy Integration provider for data masking.   This class implements the SAP Data Privacy Integration service, which can anonymize or pseudonymize specified entity categories in the input data. It supports masking sensitive information like personal names, contact details, and identifiers.   Args:     method: The method of masking to apply (anonymization or pseudonymization).       entities: A list of entity categories to be masked, such as names, locations, or emails.       allowlist: A list of strings that should not be masked.       mask_grounding_input: A flag indicating whether to mask input to the grounding module.     Method resolution order: MaskingProviderConfig gen_ai_hub.orchestration_v2.models.base.ABCBaseModel pydantic.main.BaseModel abc.ABC builtins.object Data and other attributes defined here: __abstractmethods__ = frozenset() __annotations__ = {'allowlist': typing.Optional[typing.List[str]], 'entities': typing.List[typing.Union[gen_ai_hub.orchestratio...stration_v2.models.data_masking.DPICustomEntity]], 'mask_grounding_input': typing.Optional[gen_ai_hub.orchestration_v2.models.data_masking.MaskGroundingInput], 'method': <enum 'MaskingMethod'>, 'type_': <enum 'DataMaskingProviderName'>} __class_vars__ = set() __private_attributes__ = {} __pydantic_complete__ = True __pydantic_computed_fields__ = {} __pydantic_core_schema__ = {'cls': <class 'gen_ai_hub.orchestration_v2.models.data_masking.MaskingProviderConfig'>, 'config': {'extra_fields_behavior': 'forbid', 'title': 'MaskingProviderConfig'}, 'custom_init': False, 'metadata': {'pydantic_js_functions': [<bound method BaseModel.__get_pydantic_json_sche...n_v2.models.data_masking.MaskingProviderConfig'>>]}, 'ref': 'gen_ai_hub.orchestration_v2.models.data_masking.MaskingProviderConfig:139913247044544', 'root_model': False, 'schema': {'computed_fields': [], 'fields': {'allowlist': {'metadata': {}, 'schema': {'default': None, 'schema': {'schema': {...}, 'type': 'nullable'}, 'type': 'default'}, 'type': 'model-field'}, 'entities': {'metadata': {}, 'schema': {'items_schema': {'choices': [...], 'type': 'union'}, 'type': 'list'}, 'type': 'model-field'}, 'mask_grounding_input': {'metadata': {}, 'schema': {'default': None, 'schema': {'schema': {...}, 'type': 'nullable'}, 'type': 'default'}, 'type': 'model-field'}, 'method': {'metadata': {}, 'schema': {'cls': <enum 'MaskingMethod'>, 'members': [<MaskingMethod.ANONYMIZATION: 'anonymization'>, <MaskingMethod.PSEUDONYMIZATION: 'pseudonymization'>], 'metadata': {'pydantic_js_functions': [...]}, 'ref': 'gen_ai_hub.orchestration_v2.models.data_masking.MaskingMethod:139913247174272', 'sub_type': 'str', 'type': 'enum'}, 'type': 'model-field'}, 'type_': {'metadata': {}, 'schema': {'default': <DataMaskingProviderName.SAP_DATA_PRIVACY_INTEGRATION: 'sap_data_privacy_integration'>, 'schema': {'cls': <enum 'DataMaskingProviderName'>, 'members': [...], 'metadata': {...}, 'ref': 'gen_ai_hub.orchestration_v2.models.data_masking.DataMaskingProviderName:139913247175248', 'sub_type': 'str', 'type': 'enum'}, 'type': 'default'}, 'serialization_alias': 'type', 'type': 'model-field', 'validation_alias': 'type'}}, 'model_name': 'MaskingProviderConfig', 'type': 'model-fields'}, 'type': 'model'} __pydantic_custom_init__ = False __pydantic_decorators__ = DecoratorInfos(validators={}, field_validators={...zers={}, model_validators={}, computed_fields={}) __pydantic_fields__ = {'allowlist': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None), 'entities': FieldInfo(annotation=List[Union[DPIStandardEntity, DPICustomEntity]], required=True), 'mask_grounding_input': FieldInfo(annotation=Union[MaskGroundingInput, NoneType], required=False, default=None), 'method': FieldInfo(annotation=MaskingMethod, required=True), 'type_': FieldInfo(annotation=DataMaskingProviderName, re...cy_integration'>, alias='type', alias_priority=2)} __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'parameters': ()} __pydantic_parent_namespace__ = None __pydantic_post_init__ = None __pydantic_serializer__ = SchemaSerializer(serializer=Model( ModelSeri...MaskingProviderConfig", }, ), definitions=[]) __pydantic_setattr_handlers__ = {} __pydantic_validator__ = SchemaValidator(title="MaskingProviderConfig", v...g", }, ), definitions=[], cache_strings=True) __signature__ = <Signature (*, type: gen_ai_hub.orchestration_v2...data_masking.MaskGroundingInput] = None) -> None> model_config = {'extra': 'forbid', 'frozen': False} Methods inherited from gen_ai_hub.orchestration_v2.models.base.ABCBaseModel: model_dump(self, **kwargs) Dumps the model to a dictionary with default settings. Data descriptors inherited from gen_ai_hub.orchestration_v2.models.base.ABCBaseModel: __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_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 = {'allowlist': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None), 'entities': FieldInfo(annotation=List[Union[DPIStandardEntity, DPICustomEntity]], required=True), 'mask_grounding_input': FieldInfo(annotation=Union[MaskGroundingInput, NoneType], required=False, default=None), 'method': FieldInfo(annotation=MaskingMethod, required=True), 'type_': FieldInfo(annotation=DataMaskingProviderName, re...cy_integration'>, alias='type', alias_priority=2)}   class ProfileEntity(builtins.str, enum.Enum)     ProfileEntity(value, names=None, *, module=None, qualname=None, type=None, start=1)   Enumerates the entity categories that can be masked by the SAP Data Privacy Integration service.   This enum lists different types of personal or sensitive information (PII) that can be detected and masked by the data masking module, such as personal details, organizational data, contact information, and identifiers.   Values:     PERSON: Represents personal names.       ORG: Represents organizational names.       UNIVERSITY: Represents educational institutions.       LOCATION: Represents geographical locations.       EMAIL: Represents email addresses.       PHONE: Represents phone numbers.       ADDRESS: Represents physical addresses.       SAP_IDS_INTERNAL: Represents internal SAP identifiers.       SAP_IDS_PUBLIC: Represents public SAP identifiers.       URL: Represents URLs.       USERNAME_PASSWORD: Represents usernames and passwords.       NATIONAL_ID: Represents national identification numbers.       IBAN: Represents International Bank Account Numbers.       SSN: Represents Social Security Numbers.       CREDIT_CARD_NUMBER: Represents credit card numbers.       PASSPORT: Represents passport numbers.       DRIVING_LICENSE: Represents driving license numbers.       NATIONALITY: Represents nationality information.       RELIGIOUS_GROUP: Represents religious group affiliation.       POLITICAL_GROUP: Represents political group affiliation.       PRONOUNS_GENDER: Represents pronouns and gender identity.       GENDER: Represents gender information.       SEXUAL_ORIENTATION: Represents sexual orientation.       TRADE_UNION: Represents trade union membership.       SENSITIVE_DATA: Represents any other sensitive information.     Method resolution order: ProfileEntity builtins.str enum.Enum builtins.object Data and other attributes defined here: ADDRESS = <ProfileEntity.ADDRESS: 'profile-address'> CREDIT_CARD_NUMBER = <ProfileEntity.CREDIT_CARD_NUMBER: 'profile-credit-card-number'> DRIVING_LICENSE = <ProfileEntity.DRIVING_LICENSE: 'profile-driverlicense'> EMAIL = <ProfileEntity.EMAIL: 'profile-email'> ETHNICITY = <ProfileEntity.ETHNICITY: 'profile-ethnicity'> GENDER = <ProfileEntity.GENDER: 'profile-gender'> IBAN = <ProfileEntity.IBAN: 'profile-iban'> LOCATION = <ProfileEntity.LOCATION: 'profile-location'> NATIONALITY = <ProfileEntity.NATIONALITY: 'profile-nationality'> NATIONAL_ID = <ProfileEntity.NATIONAL_ID: 'profile-nationalid'> ORG = <ProfileEntity.ORG: 'profile-org'> PASSPORT = <ProfileEntity.PASSPORT: 'profile-passport'> PERSON = <ProfileEntity.PERSON: 'profile-person'> PHONE = <ProfileEntity.PHONE: 'profile-phone'> POLITICAL_GROUP = <ProfileEntity.POLITICAL_GROUP: 'profile-political-group'> PRONOUNS_GENDER = <ProfileEntity.PRONOUNS_GENDER: 'profile-pronouns-gender'> RELIGIOUS_GROUP = <ProfileEntity.RELIGIOUS_GROUP: 'profile-religious-group'> SAP_IDS_INTERNAL = <ProfileEntity.SAP_IDS_INTERNAL: 'profile-sapids-internal'> SAP_IDS_PUBLIC = <ProfileEntity.SAP_IDS_PUBLIC: 'profile-sapids-public'> SENSITIVE_DATA = <ProfileEntity.SENSITIVE_DATA: 'profile-sensitive-data'> SEXUAL_ORIENTATION = <ProfileEntity.SEXUAL_ORIENTATION: 'profile-sexual-orientation'> SSN = <ProfileEntity.SSN: 'profile-ssn'> TRADE_UNION = <ProfileEntity.TRADE_UNION: 'profile-trade-union'> UNIVERSITY = <ProfileEntity.UNIVERSITY: 'profile-university'> URL = <ProfileEntity.URL: 'profile-url'> USERNAME_PASSWORD = <ProfileEntity.USERNAME_PASSWORD: 'profile-username-password'> 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.

Data
		List = typing.List Optional = typing.Optional Union = typing.Union