schemas (schemas)

Primary Models

Primary models are models that you can act on directly. They are the models that represent resources in the AWS service, and are acted on by the managers.

pydantic model botocraft.services.schemas.Discoverer

Bases: PrimaryBoto3Model

Show JSON schema

{
   "title": "Discoverer",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "DiscovererArn": {
         "default": null,
         "title": "Discovererarn",
         "type": "string"
      },
      "DiscovererId": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Discovererid"
      },
      "SourceArn": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Sourcearn"
      },
      "State": {
         "default": null,
         "enum": [
            "STARTED",
            "STOPPED"
         ],
         "title": "State",
         "type": "string"
      },
      "CrossAccount": {
         "anyOf": [
            {
               "type": "boolean"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Crossaccount"
      },
      "Tags": {
         "anyOf": [
            {
               "additionalProperties": {
                  "type": "string"
               },
               "type": "object"
            },
            {
               "type": "null"
            }
         ],
         "title": "Tags"
      },
      "Description": {
         "default": null,
         "title": "Description",
         "type": "string"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• CrossAccount (bool | None)

• Description (str)

• DiscovererArn (str)

• DiscovererId (str | None)

• SourceArn (str | None)

• State (Literal['STARTED', 'STOPPED'])

• Tags (dict[str, str] | None)

• session (Any | None)

field CrossAccount: bool | None = None

The Status if the discoverer will discover schemas from events sent from another account.

field Description: str = None

The description of the discoverer.

field DiscovererArn: str = None

The ARN of the discoverer.

field DiscovererId: str | None = None

The ID of the discoverer.

field SourceArn: str | None = None

The ARN of the event bus.

field State: Literal['STARTED', 'STOPPED'] = None

The state of the discoverer.

field Tags: dict[str, str] | None [Optional]

Tags associated with the resource.

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

manager_class

alias of DiscovererManager

delete()

Delete the model.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

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.

Parameters:

• _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.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

save(**kwargs)

Save the model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

property arn: str | None

Return the ARN of the model. This is the value of the DiscovererArn attribute.

Returns:

The ARN of the model instance.

property name: str | None

Get the name of the model instance.

Returns:

The name of the model instance.

Raises:

ValueError – If the model has no name identity field.

objects: ClassVar[classproperty]

Get the manager for this model, and set it as a class property

property pk: str | None

Return the primary key of the model. This is the value of the DiscovererId attribute.

Returns:

The primary key of the model instance.

pydantic model botocraft.services.schemas.Registry

Bases: PrimaryBoto3Model

Show JSON schema

{
   "title": "Registry",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "RegistryArn": {
         "default": null,
         "title": "Registryarn",
         "type": "string"
      },
      "RegistryName": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Registryname"
      },
      "Tags": {
         "anyOf": [
            {
               "additionalProperties": {
                  "type": "string"
               },
               "type": "object"
            },
            {
               "type": "null"
            }
         ],
         "title": "Tags"
      },
      "Description": {
         "default": null,
         "title": "Description",
         "type": "string"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• Description (str)

• RegistryArn (str)

• RegistryName (str | None)

• Tags (dict[str, str] | None)

• session (Any | None)

field Description: str = None

The description of the registry.

field RegistryArn: str = None

The ARN of the registry.

field RegistryName: str | None = None

The name of the registry.

field Tags: dict[str, str] | None [Optional]

Tags associated with the registry.

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

manager_class

alias of RegistryManager

delete()

Delete the model.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

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.

Parameters:

• _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.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

save(**kwargs)

Save the model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

property arn: str | None

Return the ARN of the model. This is the value of the RegistryArn attribute.

Returns:

The ARN of the model instance.

property name: str | None

Return the name of the model. This is the value of the RegistryName attribute.

Returns:

The name of the model instance.

objects: ClassVar[classproperty]

Get the manager for this model, and set it as a class property

property pk: str | None

Return the primary key of the model. This is the value of the RegistryName attribute.

Returns:

The primary key of the model instance.

pydantic model botocraft.services.schemas.Schema

Bases: PrimaryBoto3Model

A summary of schema details.

Show JSON schema

{
   "title": "Schema",
   "description": "A summary of schema details.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "LastModified": {
         "default": null,
         "format": "date-time",
         "title": "Lastmodified",
         "type": "string"
      },
      "SchemaArn": {
         "default": null,
         "title": "Schemaarn",
         "type": "string"
      },
      "SchemaName": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Schemaname"
      },
      "Tags": {
         "anyOf": [
            {
               "additionalProperties": {
                  "type": "string"
               },
               "type": "object"
            },
            {
               "type": "null"
            }
         ],
         "title": "Tags"
      },
      "VersionCount": {
         "default": null,
         "title": "Versioncount",
         "type": "integer"
      },
      "RegistryName": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Registryname"
      },
      "Content": {
         "default": null,
         "title": "Content",
         "type": "string"
      },
      "Description": {
         "default": null,
         "title": "Description",
         "type": "string"
      },
      "SchemaVersion": {
         "default": null,
         "title": "Schemaversion",
         "type": "string"
      },
      "Type": {
         "default": null,
         "title": "Type",
         "type": "string"
      },
      "VersionCreatedDate": {
         "default": null,
         "format": "date-time",
         "title": "Versioncreateddate",
         "type": "string"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• Content (str)

• Description (str)

• LastModified (datetime.datetime)

• RegistryName (str | None)

• SchemaArn (str)

• SchemaName (str | None)

• SchemaVersion (str)

• Tags (dict[str, str] | None)

• Type (str)

• VersionCount (int)

• VersionCreatedDate (datetime.datetime)

• session (Any | None)

field Content: str = None

The source of the schema definition.

field Description: str = None

The description of the schema.

field LastModified: datetime = None

The date and time that schema was modified.

field RegistryName: str | None = None

The registry that owns this schema.

field SchemaArn: str = None

The ARN of the schema.

field SchemaName: str | None = None

The name of the schema.

field SchemaVersion: str = None

The version number of the schema.

field Tags: dict[str, str] | None [Optional]

Tags associated with the schema.

field Type: str = None

The type of the schema.

field VersionCount: int = None

The number of versions available for the schema.

field VersionCreatedDate: datetime = None

The date the schema version was created.

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

manager_class

alias of SchemaManager

delete()

Delete the model.

export(SchemaVersion: str | None = None) → ExportSchemaResponse | None

Export this schema in the requested format.

Keyword Arguments:

SchemaVersion – Specifying this limits the results to only this schema version.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

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.

Parameters:

• _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.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

save(**kwargs)

Save the model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

versions() → list[botocraft.services.schemas.SchemaVersionSummary]

Return the versions that belong to this schema.

property arn: str | None

Return the ARN of the model. This is the value of the SchemaArn attribute.

Returns:

The ARN of the model instance.

property name: str | None

Return the name of the model. This is the value of the SchemaName attribute.

Returns:

The name of the model instance.

objects: ClassVar[classproperty]

Get the manager for this model, and set it as a class property

property pk: str | None

Return the primary key of the model. This is the value of the SchemaArn attribute.

Returns:

The primary key of the model instance.

Managers

Managers work with the primary models to provide a high-level interface to the AWS service. They are responsible for creating, updating, and deleting the resources in the service, as well as any additional operations that are available for those models.

class botocraft.services.schemas.DiscovererManager

Bases: Boto3ModelManager

create(model: Discoverer) → CreateDiscovererResponse

Creates a discoverer.

Parameters:

model – The DiscovererSummary to create.

delete(DiscovererId: str) → None

Deletes a discoverer.

Parameters:

DiscovererId – The ID of the discoverer.

get(DiscovererId: str) → DescribeDiscovererResponse | None

Describes the discoverer.

Parameters:

DiscovererId – The ID of the discoverer.

list(*, DiscovererIdPrefix: str | None = None, Limit: int | None = None, SourceArnPrefix: str | None = None) → PrimaryBoto3ModelQuerySet

List the discoverers.

Keyword Arguments:

• DiscovererIdPrefix – Specifying this limits the results to only those discoverer IDs that start with the specified prefix.

• Limit – the value to set for Limit

• SourceArnPrefix – Specifying this limits the results to only those ARNs that start with the specified prefix.

start(DiscovererId: str) → StartDiscovererResponse

Starts the discoverer.

Parameters:

DiscovererId – The ID of the discoverer.

stop(DiscovererId: str) → StopDiscovererResponse

Stops the discoverer.

Parameters:

DiscovererId – The ID of the discoverer.

update(model: Discoverer) → UpdateDiscovererResponse

Updates the discoverer.

Parameters:

model – The DiscovererSummary to update.

service_name: str = 'schemas'

ec2, s3, etc.

Type:

The name of the boto3 service. Example

class botocraft.services.schemas.RegistryManager

Bases: Boto3ModelManager

create(model: Registry) → CreateRegistryResponse

Creates a registry.

Parameters:

model – The RegistrySummary to create.

delete(RegistryName: str) → None

Deletes a Registry.

Parameters:

RegistryName – The name of the registry.

get(RegistryName: str) → DescribeRegistryResponse | None

Describes the registry.

Parameters:

RegistryName – The name of the registry.

list(*, Limit: int | None = None, RegistryNamePrefix: str | None = None, Scope: str | None = None) → PrimaryBoto3ModelQuerySet

List the registries.

Keyword Arguments:

• Limit – the value to set for Limit

• RegistryNamePrefix – Specifying this limits the results to only those registry names that start with the specified prefix.

• Scope – Can be set to Local or AWS to limit responses to your custom registries, or the ones provided by AWS.

update(model: Registry) → UpdateRegistryResponse

Updates a registry.

Parameters:

model – The RegistrySummary to update.

service_name: str = 'schemas'

ec2, s3, etc.

Type:

The name of the boto3 service. Example

class botocraft.services.schemas.SchemaManager

Bases: Boto3ModelManager

create(model: Schema) → CreateSchemaResponse

Creates a schema definition.

Parameters:

model – The SchemaSummary to create.

delete(RegistryName: str, SchemaName: str) → None

Delete a schema definition.

Parameters:

• RegistryName – The name of the registry.

• SchemaName – The name of the schema.

export(RegistryName: str, SchemaName: str, Type: str, *, SchemaVersion: str | None = None) → ExportSchemaResponse | None

Parameters:

• RegistryName – The name of the registry.

• SchemaName – The name of the schema.

• Type – the value to set for Type

Keyword Arguments:

SchemaVersion – Specifying this limits the results to only this schema version.

get(RegistryName: str, SchemaName: str, *, SchemaVersion: str | None = None) → DescribeSchemaResponse | None

Retrieve the schema definition.

Parameters:

• RegistryName – The name of the registry.

• SchemaName – The name of the schema.

Keyword Arguments:

SchemaVersion – Specifying this limits the results to only this schema version.

list(RegistryName: str, *, Limit: int | None = None, SchemaNamePrefix: str | None = None) → PrimaryBoto3ModelQuerySet

List the schemas.

Parameters:

RegistryName – The name of the registry.

Keyword Arguments:

• Limit – the value to set for Limit

• SchemaNamePrefix – Specifying this limits the results to only those schema names that start with the specified prefix.

list_versions(RegistryName: str, SchemaName: str, *, Limit: int | None = None) → list[botocraft.services.schemas.SchemaVersionSummary]

Provides a list of the schema versions and related information.

Parameters:

• RegistryName – The name of the registry.

• SchemaName – The name of the schema.

Keyword Arguments:

Limit – the value to set for Limit

update(model: Schema, ClientTokenId: str | None = None) → UpdateSchemaResponse

Updates the schema definition.

Parameters:

model – The SchemaSummary to update.

Keyword Arguments:

ClientTokenId – The ID of the client token.

service_name: str = 'schemas'

ec2, s3, etc.

Type:

The name of the boto3 service. Example

Secondary Models

Secondary models are models that are used by the primary models to organize their data. They are not acted on directly, but are used to describe the structure of the fields in the primary models or other secondary models.

Request/Response Models

Request/response models are models that are used to describe the structure of the data that is sent to and received from the AWS service. They are used by the managers to send requests to the service and to parse the responses that are received.

You will not often use them directly – typically they are used by the managers internally to send requests and parse responses – but they are included here for completeness, and because occasionally we return them directly to you because they have some useful additional information.

pydantic model botocraft.services.schemas.CreateDiscovererResponse

Bases: Boto3Model

Show JSON schema

{
   "title": "CreateDiscovererResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "Description": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Description"
      },
      "DiscovererArn": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Discovererarn"
      },
      "DiscovererId": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Discovererid"
      },
      "SourceArn": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Sourcearn"
      },
      "State": {
         "anyOf": [
            {
               "enum": [
                  "STARTED",
                  "STOPPED"
               ],
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "State"
      },
      "CrossAccount": {
         "anyOf": [
            {
               "type": "boolean"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Crossaccount"
      },
      "Tags": {
         "anyOf": [
            {
               "additionalProperties": {
                  "type": "string"
               },
               "type": "object"
            },
            {
               "type": "null"
            }
         ],
         "title": "Tags"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• CrossAccount (bool | None)

• Description (str | None)

• DiscovererArn (str | None)

• DiscovererId (str | None)

• SourceArn (str | None)

• State (Literal['STARTED', 'STOPPED'] | None)

• Tags (dict[str, str] | None)

• session (Any | None)

field CrossAccount: bool | None = None

The Status if the discoverer will discover schemas from events sent from another account.

field Description: str | None = None

The description of the discoverer.

field DiscovererArn: str | None = None

The ARN of the discoverer.

field DiscovererId: str | None = None

The ID of the discoverer.

field SourceArn: str | None = None

The ARN of the event bus.

field State: Literal['STARTED', 'STOPPED'] | None = None

The state of the discoverer.

field Tags: dict[str, str] | None [Optional]

Tags associated with the resource.

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

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.

Parameters:

• _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.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

pydantic model botocraft.services.schemas.CreateRegistryResponse

Bases: Boto3Model

Show JSON schema

{
   "title": "CreateRegistryResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "Description": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Description"
      },
      "RegistryArn": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Registryarn"
      },
      "RegistryName": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Registryname"
      },
      "Tags": {
         "anyOf": [
            {
               "additionalProperties": {
                  "type": "string"
               },
               "type": "object"
            },
            {
               "type": "null"
            }
         ],
         "title": "Tags"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• Description (str | None)

• RegistryArn (str | None)

• RegistryName (str | None)

• Tags (dict[str, str] | None)

• session (Any | None)

field Description: str | None = None

The description of the registry.

field RegistryArn: str | None = None

The ARN of the registry.

field RegistryName: str | None = None

The name of the registry.

field Tags: dict[str, str] | None [Optional]

Tags associated with the registry.

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

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.

Parameters:

• _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.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

pydantic model botocraft.services.schemas.CreateSchemaResponse

Bases: Boto3Model

Show JSON schema

{
   "title": "CreateSchemaResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "Description": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Description"
      },
      "LastModified": {
         "anyOf": [
            {
               "format": "date-time",
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Lastmodified"
      },
      "SchemaArn": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Schemaarn"
      },
      "SchemaName": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Schemaname"
      },
      "SchemaVersion": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Schemaversion"
      },
      "Tags": {
         "anyOf": [
            {
               "additionalProperties": {
                  "type": "string"
               },
               "type": "object"
            },
            {
               "type": "null"
            }
         ],
         "title": "Tags"
      },
      "Type": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Type"
      },
      "VersionCreatedDate": {
         "anyOf": [
            {
               "format": "date-time",
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Versioncreateddate"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• Description (str | None)

• LastModified (datetime.datetime | None)

• SchemaArn (str | None)

• SchemaName (str | None)

• SchemaVersion (str | None)

• Tags (dict[str, str] | None)

• Type (str | None)

• VersionCreatedDate (datetime.datetime | None)

• session (Any | None)

field Description: str | None = None

The description of the schema.

field LastModified: datetime | None = None

The date and time that schema was modified.

field SchemaArn: str | None = None

The ARN of the schema.

field SchemaName: str | None = None

The name of the schema.

field SchemaVersion: str | None = None

The version number of the schema.

field Tags: dict[str, str] | None [Optional]

Key-value pairs associated with a resource.

field Type: str | None = None

The type of the schema.

field VersionCreatedDate: datetime | None = None

The date the schema version was created.

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

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.

Parameters:

• _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.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

pydantic model botocraft.services.schemas.DescribeDiscovererResponse

Bases: Boto3Model

Show JSON schema

{
   "title": "DescribeDiscovererResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "Description": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Description"
      },
      "DiscovererArn": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Discovererarn"
      },
      "DiscovererId": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Discovererid"
      },
      "SourceArn": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Sourcearn"
      },
      "State": {
         "anyOf": [
            {
               "enum": [
                  "STARTED",
                  "STOPPED"
               ],
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "State"
      },
      "CrossAccount": {
         "anyOf": [
            {
               "type": "boolean"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Crossaccount"
      },
      "Tags": {
         "anyOf": [
            {
               "additionalProperties": {
                  "type": "string"
               },
               "type": "object"
            },
            {
               "type": "null"
            }
         ],
         "title": "Tags"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• CrossAccount (bool | None)

• Description (str | None)

• DiscovererArn (str | None)

• DiscovererId (str | None)

• SourceArn (str | None)

• State (Literal['STARTED', 'STOPPED'] | None)

• Tags (dict[str, str] | None)

• session (Any | None)

field CrossAccount: bool | None = None

The Status if the discoverer will discover schemas from events sent from another account.

field Description: str | None = None

The description of the discoverer.

field DiscovererArn: str | None = None

The ARN of the discoverer.

field DiscovererId: str | None = None

The ID of the discoverer.

field SourceArn: str | None = None

The ARN of the event bus.

field State: Literal['STARTED', 'STOPPED'] | None = None

The state of the discoverer.

field Tags: dict[str, str] | None [Optional]

Tags associated with the resource.

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

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.

Parameters:

• _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.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

pydantic model botocraft.services.schemas.DescribeRegistryResponse

Bases: Boto3Model

Show JSON schema

{
   "title": "DescribeRegistryResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "Description": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Description"
      },
      "RegistryArn": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Registryarn"
      },
      "RegistryName": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Registryname"
      },
      "Tags": {
         "anyOf": [
            {
               "additionalProperties": {
                  "type": "string"
               },
               "type": "object"
            },
            {
               "type": "null"
            }
         ],
         "title": "Tags"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• Description (str | None)

• RegistryArn (str | None)

• RegistryName (str | None)

• Tags (dict[str, str] | None)

• session (Any | None)

field Description: str | None = None

The description of the registry.

field RegistryArn: str | None = None

The ARN of the registry.

field RegistryName: str | None = None

The name of the registry.

field Tags: dict[str, str] | None [Optional]

Tags associated with the registry.

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

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.

Parameters:

• _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.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

pydantic model botocraft.services.schemas.DescribeSchemaResponse

Bases: Boto3Model

Show JSON schema

{
   "title": "DescribeSchemaResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "Content": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Content"
      },
      "Description": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Description"
      },
      "LastModified": {
         "anyOf": [
            {
               "format": "date-time",
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Lastmodified"
      },
      "SchemaArn": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Schemaarn"
      },
      "SchemaName": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Schemaname"
      },
      "SchemaVersion": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Schemaversion"
      },
      "Tags": {
         "anyOf": [
            {
               "additionalProperties": {
                  "type": "string"
               },
               "type": "object"
            },
            {
               "type": "null"
            }
         ],
         "title": "Tags"
      },
      "Type": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Type"
      },
      "VersionCreatedDate": {
         "anyOf": [
            {
               "format": "date-time",
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Versioncreateddate"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• Content (str | None)

• Description (str | None)

• LastModified (datetime.datetime | None)

• SchemaArn (str | None)

• SchemaName (str | None)

• SchemaVersion (str | None)

• Tags (dict[str, str] | None)

• Type (str | None)

• VersionCreatedDate (datetime.datetime | None)

• session (Any | None)

field Content: str | None = None

The source of the schema definition.

field Description: str | None = None

The description of the schema.

field LastModified: datetime | None = None

The date and time that schema was modified.

field SchemaArn: str | None = None

The ARN of the schema.

field SchemaName: str | None = None

The name of the schema.

field SchemaVersion: str | None = None

The version number of the schema.

field Tags: dict[str, str] | None [Optional]

Tags associated with the resource.

field Type: str | None = None

The type of the schema.

field VersionCreatedDate: datetime | None = None

The date the schema version was created.

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

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.

Parameters:

• _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.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

pydantic model botocraft.services.schemas.ExportSchemaResponse

Bases: Boto3Model

Show JSON schema

{
   "title": "ExportSchemaResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "Content": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Content"
      },
      "SchemaArn": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Schemaarn"
      },
      "SchemaName": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Schemaname"
      },
      "SchemaVersion": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Schemaversion"
      },
      "Type": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Type"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• Content (str | None)

• SchemaArn (str | None)

• SchemaName (str | None)

• SchemaVersion (str | None)

• Type (str | None)

• session (Any | None)

field Content: str | None = None

field SchemaArn: str | None = None

field SchemaName: str | None = None

field SchemaVersion: str | None = None

field Type: str | None = None

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

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.

Parameters:

• _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.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

pydantic model botocraft.services.schemas.ListDiscoverersResponse

Bases: Boto3Model

Show JSON schema

{
   "title": "ListDiscoverersResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "Discoverers": {
         "anyOf": [
            {
               "items": {
                  "$ref": "#/$defs/Discoverer"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Discoverers"
      },
      "NextToken": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Nexttoken"
      }
   },
   "$defs": {
      "Discoverer": {
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "DiscovererArn": {
               "default": null,
               "title": "Discovererarn",
               "type": "string"
            },
            "DiscovererId": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Discovererid"
            },
            "SourceArn": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Sourcearn"
            },
            "State": {
               "default": null,
               "enum": [
                  "STARTED",
                  "STOPPED"
               ],
               "title": "State",
               "type": "string"
            },
            "CrossAccount": {
               "anyOf": [
                  {
                     "type": "boolean"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Crossaccount"
            },
            "Tags": {
               "anyOf": [
                  {
                     "additionalProperties": {
                        "type": "string"
                     },
                     "type": "object"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Tags"
            },
            "Description": {
               "default": null,
               "title": "Description",
               "type": "string"
            }
         },
         "title": "Discoverer",
         "type": "object"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• Discoverers (list[botocraft.services.schemas.Discoverer] | None)

• NextToken (str | None)

• session (Any | None)

field Discoverers: builtins.list[Discoverer] | None [Optional]

An array of DiscovererSummary information.

field NextToken: str | None = None

The token that specifies the next page of results to return.

To request the first page, leave NextToken empty. The token will expire in 24 hours, and cannot be shared with other accounts.

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

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.

Parameters:

• _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.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

pydantic model botocraft.services.schemas.ListRegistriesResponse

Bases: Boto3Model

Show JSON schema

{
   "title": "ListRegistriesResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "NextToken": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Nexttoken"
      },
      "Registries": {
         "anyOf": [
            {
               "items": {
                  "$ref": "#/$defs/Registry"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Registries"
      }
   },
   "$defs": {
      "Registry": {
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "RegistryArn": {
               "default": null,
               "title": "Registryarn",
               "type": "string"
            },
            "RegistryName": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Registryname"
            },
            "Tags": {
               "anyOf": [
                  {
                     "additionalProperties": {
                        "type": "string"
                     },
                     "type": "object"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Tags"
            },
            "Description": {
               "default": null,
               "title": "Description",
               "type": "string"
            }
         },
         "title": "Registry",
         "type": "object"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• NextToken (str | None)

• Registries (list[botocraft.services.schemas.Registry] | None)

• session (Any | None)

field NextToken: str | None = None

The token that specifies the next page of results to return.

To request the first page, leave NextToken empty. The token will expire in 24 hours, and cannot be shared with other accounts.

field Registries: builtins.list[Registry] | None [Optional]

An array of registry summaries.

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

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.

Parameters:

• _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.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

pydantic model botocraft.services.schemas.ListSchemaVersionsResponse

Bases: Boto3Model

Show JSON schema

{
   "title": "ListSchemaVersionsResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "NextToken": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Nexttoken"
      },
      "SchemaVersions": {
         "anyOf": [
            {
               "items": {
                  "$ref": "#/$defs/SchemaVersionSummary"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Schemaversions"
      }
   },
   "$defs": {
      "SchemaVersionSummary": {
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "SchemaArn": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Schemaarn"
            },
            "SchemaName": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Schemaname"
            },
            "SchemaVersion": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Schemaversion"
            },
            "Type": {
               "anyOf": [
                  {
                     "enum": [
                        "OpenApi3",
                        "JSONSchemaDraft4"
                     ],
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Type"
            }
         },
         "title": "SchemaVersionSummary",
         "type": "object"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• NextToken (str | None)

• SchemaVersions (list[botocraft.services.schemas.SchemaVersionSummary] | None)

• session (Any | None)

field NextToken: str | None = None

The token that specifies the next page of results to return.

To request the first page, leave NextToken empty. The token will expire in 24 hours, and cannot be shared with other accounts.

field SchemaVersions: builtins.list[SchemaVersionSummary] | None [Optional]

An array of schema version summaries.

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

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.

Parameters:

• _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.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

pydantic model botocraft.services.schemas.ListSchemasResponse

Bases: Boto3Model

Show JSON schema

{
   "title": "ListSchemasResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "NextToken": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Nexttoken"
      },
      "Schemas": {
         "anyOf": [
            {
               "items": {
                  "$ref": "#/$defs/Schema"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Schemas"
      }
   },
   "$defs": {
      "Schema": {
         "description": "A summary of schema details.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "LastModified": {
               "default": null,
               "format": "date-time",
               "title": "Lastmodified",
               "type": "string"
            },
            "SchemaArn": {
               "default": null,
               "title": "Schemaarn",
               "type": "string"
            },
            "SchemaName": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Schemaname"
            },
            "Tags": {
               "anyOf": [
                  {
                     "additionalProperties": {
                        "type": "string"
                     },
                     "type": "object"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Tags"
            },
            "VersionCount": {
               "default": null,
               "title": "Versioncount",
               "type": "integer"
            },
            "RegistryName": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Registryname"
            },
            "Content": {
               "default": null,
               "title": "Content",
               "type": "string"
            },
            "Description": {
               "default": null,
               "title": "Description",
               "type": "string"
            },
            "SchemaVersion": {
               "default": null,
               "title": "Schemaversion",
               "type": "string"
            },
            "Type": {
               "default": null,
               "title": "Type",
               "type": "string"
            },
            "VersionCreatedDate": {
               "default": null,
               "format": "date-time",
               "title": "Versioncreateddate",
               "type": "string"
            }
         },
         "title": "Schema",
         "type": "object"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• NextToken (str | None)

• Schemas (list[botocraft.services.schemas.Schema] | None)

• session (Any | None)

field NextToken: str | None = None

The token that specifies the next page of results to return.

To request the first page, leave NextToken empty. The token will expire in 24 hours, and cannot be shared with other accounts.

field Schemas: builtins.list[Schema] | None [Optional]

An array of schema summaries.

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

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.

Parameters:

• _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.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

pydantic model botocraft.services.schemas.SchemaVersionSummary

Bases: Boto3Model

Show JSON schema

{
   "title": "SchemaVersionSummary",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "SchemaArn": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Schemaarn"
      },
      "SchemaName": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Schemaname"
      },
      "SchemaVersion": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Schemaversion"
      },
      "Type": {
         "anyOf": [
            {
               "enum": [
                  "OpenApi3",
                  "JSONSchemaDraft4"
               ],
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Type"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• SchemaArn (str | None)

• SchemaName (str | None)

• SchemaVersion (str | None)

• Type (Literal['OpenApi3', 'JSONSchemaDraft4'] | None)

• session (Any | None)

field SchemaArn: str | None = None

The ARN of the schema version.

field SchemaName: str | None = None

The name of the schema.

field SchemaVersion: str | None = None

The version number of the schema.

field Type: Literal['OpenApi3', 'JSONSchemaDraft4'] | None = None

The type of schema.

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

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.

Parameters:

• _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.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

pydantic model botocraft.services.schemas.StartDiscovererResponse

Bases: Boto3Model

Show JSON schema

{
   "title": "StartDiscovererResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "DiscovererId": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Discovererid"
      },
      "State": {
         "anyOf": [
            {
               "enum": [
                  "STARTED",
                  "STOPPED"
               ],
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "State"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• DiscovererId (str | None)

• State (Literal['STARTED', 'STOPPED'] | None)

• session (Any | None)

field DiscovererId: str | None = None

The ID of the discoverer.

field State: Literal['STARTED', 'STOPPED'] | None = None

The state of the discoverer.

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

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.

Parameters:

• _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.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

pydantic model botocraft.services.schemas.StopDiscovererResponse

Bases: Boto3Model

Show JSON schema

{
   "title": "StopDiscovererResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "DiscovererId": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Discovererid"
      },
      "State": {
         "anyOf": [
            {
               "enum": [
                  "STARTED",
                  "STOPPED"
               ],
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "State"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• DiscovererId (str | None)

• State (Literal['STARTED', 'STOPPED'] | None)

• session (Any | None)

field DiscovererId: str | None = None

The ID of the discoverer.

field State: Literal['STARTED', 'STOPPED'] | None = None

The state of the discoverer.

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

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.

Parameters:

• _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.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

pydantic model botocraft.services.schemas.UpdateDiscovererResponse

Bases: Boto3Model

Show JSON schema

{
   "title": "UpdateDiscovererResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "Description": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Description"
      },
      "DiscovererArn": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Discovererarn"
      },
      "DiscovererId": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Discovererid"
      },
      "SourceArn": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Sourcearn"
      },
      "State": {
         "anyOf": [
            {
               "enum": [
                  "STARTED",
                  "STOPPED"
               ],
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "State"
      },
      "CrossAccount": {
         "anyOf": [
            {
               "type": "boolean"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Crossaccount"
      },
      "Tags": {
         "anyOf": [
            {
               "additionalProperties": {
                  "type": "string"
               },
               "type": "object"
            },
            {
               "type": "null"
            }
         ],
         "title": "Tags"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• CrossAccount (bool | None)

• Description (str | None)

• DiscovererArn (str | None)

• DiscovererId (str | None)

• SourceArn (str | None)

• State (Literal['STARTED', 'STOPPED'] | None)

• Tags (dict[str, str] | None)

• session (Any | None)

field CrossAccount: bool | None = None

The Status if the discoverer will discover schemas from events sent from another account.

field Description: str | None = None

The description of the discoverer.

field DiscovererArn: str | None = None

The ARN of the discoverer.

field DiscovererId: str | None = None

The ID of the discoverer.

field SourceArn: str | None = None

The ARN of the event bus.

field State: Literal['STARTED', 'STOPPED'] | None = None

The state of the discoverer.

field Tags: dict[str, str] | None [Optional]

Tags associated with the resource.

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

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.

Parameters:

• _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.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

pydantic model botocraft.services.schemas.UpdateRegistryResponse

Bases: Boto3Model

Show JSON schema

{
   "title": "UpdateRegistryResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "Description": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Description"
      },
      "RegistryArn": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Registryarn"
      },
      "RegistryName": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Registryname"
      },
      "Tags": {
         "anyOf": [
            {
               "additionalProperties": {
                  "type": "string"
               },
               "type": "object"
            },
            {
               "type": "null"
            }
         ],
         "title": "Tags"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• Description (str | None)

• RegistryArn (str | None)

• RegistryName (str | None)

• Tags (dict[str, str] | None)

• session (Any | None)

field Description: str | None = None

The description of the registry.

field RegistryArn: str | None = None

The ARN of the registry.

field RegistryName: str | None = None

The name of the registry.

field Tags: dict[str, str] | None [Optional]

Tags associated with the registry.

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

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.

Parameters:

• _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.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.

pydantic model botocraft.services.schemas.UpdateSchemaResponse

Bases: Boto3Model

Show JSON schema

{
   "title": "UpdateSchemaResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "Description": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Description"
      },
      "LastModified": {
         "anyOf": [
            {
               "format": "date-time",
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Lastmodified"
      },
      "SchemaArn": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Schemaarn"
      },
      "SchemaName": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Schemaname"
      },
      "SchemaVersion": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Schemaversion"
      },
      "Tags": {
         "anyOf": [
            {
               "additionalProperties": {
                  "type": "string"
               },
               "type": "object"
            },
            {
               "type": "null"
            }
         ],
         "title": "Tags"
      },
      "Type": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Type"
      },
      "VersionCreatedDate": {
         "anyOf": [
            {
               "format": "date-time",
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Versioncreateddate"
      }
   }
}

Config:

• validate_assignment: bool = True

• arbitrary_types_allowed: bool = True

Fields:

• Description (str | None)

• LastModified (datetime.datetime | None)

• SchemaArn (str | None)

• SchemaName (str | None)

• SchemaVersion (str | None)

• Tags (dict[str, str] | None)

• Type (str | None)

• VersionCreatedDate (datetime.datetime | None)

• session (Any | None)

field Description: str | None = None

The description of the schema.

field LastModified: datetime | None = None

The date and time that schema was modified.

field SchemaArn: str | None = None

The ARN of the schema.

field SchemaName: str | None = None

The name of the schema.

field SchemaVersion: str | None = None

The version number of the schema.

field Tags: dict[str, str] | None [Optional]

Key-value pairs associated with a resource.

field Type: str | None = None

The type of the schema.

field VersionCreatedDate: datetime | None = None

The date the schema version was created.

field session: Any | None = None

The boto3 session to use for this model. This is set by the manager, and is used in relationships. We have to use Any here because we pydantic complains vociferously if we use boto3.session.Session. We exclude it from the model dump because it’s not something that should be serialized.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Self

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.

Parameters:

• _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.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: Any | None = None, by_alias: bool | None = None, by_name: bool | None = None) → Self

Validate the given object with string data against the Pydantic model.

Parameters:

• obj – The object containing string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

• by_alias – Whether to use the field’s alias when validating against the provided input data.

• by_name – Whether to use the field’s name when validating against the provided input data.

Returns:

The validated Pydantic model.

set_session(session: Session) → None

Set the boto3 session for this model.

Parameters:

session – The boto3 session to use.

Returns:

The model instance.

transform(attribute: str, transformer: str | None) → Any

Transform an attribute using a regular expression into something else before it is returned.

Important

This only makes sense for attributes that are strings.

transformer is a regular expression that will be used to transform the value of the attribute.

• If the attribute is None, it will be returned verbatim.

• If transformer is None, the attribute will be returned verbatim.

• If transformer has no named groups, the attribute will be replaced with the value of the first group.

• If transformer has named groups, the attribute will be replaced with a dictionary of the named groups.

Raises:

• ValueError – If the attribute does not exist on the model.

• RuntimeError – If the transformer fails to match the attribute value.

Parameters:

• attribute – The attribute to transform.

• transformer – The regular expression to use to transform the attribute.

Returns:

The transformed attribute.