Secrets Manager (secretsmanager)

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.secretsmanager.Secret[source]

Bases: TagsDictMixin, PrimaryBoto3Model

A structure that contains the details about a secret.

It does not include the encrypted SecretString and SecretBinary values. To get those values, use GetSecretValue .

Show JSON schema

{
   "title": "Secret",
   "description": "A structure that contains the details about a secret.\n\nIt does not include the encrypted ``SecretString`` and\n``SecretBinary`` values. To get those values, use\n`GetSecretValue <https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html>`_ .",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "Name": {
         "title": "Name",
         "type": "string"
      },
      "ARN": {
         "default": null,
         "title": "Arn",
         "type": "string"
      },
      "Type": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Type"
      },
      "Description": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Description"
      },
      "KmsKeyId": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Kmskeyid"
      },
      "RotationEnabled": {
         "default": null,
         "title": "Rotationenabled",
         "type": "boolean"
      },
      "RotationLambdaARN": {
         "default": null,
         "title": "Rotationlambdaarn",
         "type": "string"
      },
      "RotationRules": {
         "$ref": "#/$defs/RotationRulesType",
         "default": null
      },
      "ExternalSecretRotationMetadata": {
         "items": {
            "$ref": "#/$defs/ExternalSecretRotationMetadataItem"
         },
         "title": "Externalsecretrotationmetadata",
         "type": "array"
      },
      "ExternalSecretRotationRoleArn": {
         "default": null,
         "title": "Externalsecretrotationrolearn",
         "type": "string"
      },
      "LastRotatedDate": {
         "default": null,
         "format": "date-time",
         "title": "Lastrotateddate",
         "type": "string"
      },
      "LastChangedDate": {
         "default": null,
         "format": "date-time",
         "title": "Lastchangeddate",
         "type": "string"
      },
      "LastAccessedDate": {
         "default": null,
         "format": "date-time",
         "title": "Lastaccesseddate",
         "type": "string"
      },
      "DeletedDate": {
         "default": null,
         "format": "date-time",
         "title": "Deleteddate",
         "type": "string"
      },
      "NextRotationDate": {
         "default": null,
         "format": "date-time",
         "title": "Nextrotationdate",
         "type": "string"
      },
      "Tags": {
         "anyOf": [
            {
               "items": {
                  "$ref": "#/$defs/Tag"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Tags"
      },
      "SecretVersionsToStages": {
         "additionalProperties": {
            "items": {
               "type": "string"
            },
            "type": "array"
         },
         "title": "Secretversionstostages",
         "type": "object"
      },
      "OwningService": {
         "default": null,
         "title": "Owningservice",
         "type": "string"
      },
      "CreatedDate": {
         "default": null,
         "format": "date-time",
         "title": "Createddate",
         "type": "string"
      },
      "PrimaryRegion": {
         "default": null,
         "title": "Primaryregion",
         "type": "string"
      }
   },
   "$defs": {
      "ExternalSecretRotationMetadataItem": {
         "description": "The metadata needed to successfully rotate a managed external secret.\n\nA list of key value pairs in JSON format specified by the partner. For more\ninformation, see\n`Managed external secret partners <https://docs.aws.amazon.com/secretsmanager/latest/userguide/mes-partners.html>`_.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Key": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Key"
            },
            "Value": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Value"
            }
         },
         "title": "ExternalSecretRotationMetadataItem",
         "type": "object"
      },
      "RotationRulesType": {
         "description": "A structure that defines the rotation configuration for the secret.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "AutomaticallyAfterDays": {
               "anyOf": [
                  {
                     "type": "integer"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Automaticallyafterdays"
            },
            "Duration": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Duration"
            },
            "ScheduleExpression": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Scheduleexpression"
            }
         },
         "title": "RotationRulesType",
         "type": "object"
      },
      "Tag": {
         "description": "The metadata that you apply to a resource to help you categorize and\norganize them. Each tag consists of a key and an optional value. You define\nthem.\n\nThe following basic restrictions apply to tags:\n\n* Maximum number of tags per resource - 50\n* For each resource, each tag key must be unique, and each tag key can have\n  only one value.\n* Maximum key length - 128 Unicode characters in UTF-8\n* Maximum value length - 256 Unicode characters in UTF-8\n* If your tagging schema is used across multiple services and resources,\n  remember that other services may have restrictions on allowed characters.\n  Generally allowed characters are: letters, numbers, and spaces representable in\n  UTF-8, and the following characters: + - = . _ : / @.\n* Tag keys and values are case-sensitive.\n* Do not use ``aws:``, ``AWS:``, or any upper or lowercase combination of such\n  as a prefix for either keys or values as it is reserved for Amazon Web Services\n  use. You cannot edit or delete tag keys or values with this prefix. Tags with\n  this prefix do not count against your tags per resource limit.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Key": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Key"
            },
            "Value": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Value"
            }
         },
         "title": "Tag",
         "type": "object"
      }
   },
   "required": [
      "Name"
   ]
}

field ARN: str = None: The Amazon Resource Name (ARN) of the secret.

field CreatedDate: datetime = None: The date and time when a secret was created.

field DeletedDate: datetime = None

The date and time the deletion of the secret occurred.

Not present on active secrets. The secret can be recovered until the number of days in the recovery window has passed, as specified in the RecoveryWindowInDays parameter of the `DeleteSecret <https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_DeleteSecret.html>`_ operation.

field Description: str | None = None: The user-provided description of the secret.

field ExternalSecretRotationMetadata: builtins.list[ExternalSecretRotationMetadataItem] [Optional]

The metadata needed to successfully rotate a managed external secret.

A list of key value pairs in JSON format specified by the partner. For more information about the required information, see Managed external secrets partners.

field ExternalSecretRotationRoleArn: str = None

The role that Secrets Manager assumes to call APIs required to perform the rotation.

For more information about the required information, see Managed external secrets partners.

field KmsKeyId: str | None = None

The ARN of the KMS key that Secrets Manager uses to encrypt the secret value.

If the secret is encrypted with the Amazon Web Services managed key aws/secretsmanager, this field is omitted.

field LastAccessedDate: datetime = None

The date that the secret was last accessed in the Region.

This field is omitted if the secret has never been retrieved in the Region.

field LastChangedDate: datetime = None: The last date and time that this secret was modified in any way.

field LastRotatedDate: datetime = None

The most recent date and time that the Secrets Manager rotation process was successfully completed.

This value is null if the secret hasn’t ever rotated.

field Name: str [Required]: The friendly name of the secret.

field NextRotationDate: datetime = None

The next rotation is scheduled to occur on or before this date.

If the secret isn’t configured for rotation or rotation has been disabled, Secrets Manager returns null.

field OwningService: str = None: Returns the name of the service that created the secret.

field PrimaryRegion: str = None: The Region where Secrets Manager originated the secret.

field RotationEnabled: bool = None: Indicates whether automatic, scheduled rotation is enabled for this secret.

field RotationLambdaARN: str = None: The ARN of an Amazon Web Services Lambda function invoked by Secrets Manager to rotate and expire the secret either automatically per the schedule or manually by a call to `RotateSecret <https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_RotateSecret.html>`_ .

field RotationRules: RotationRulesType = None: A structure that defines the rotation configuration for the secret.

field SecretVersionsToStages: dict[str, list[str]] [Optional]

A list of all of the currently assigned SecretVersionStage staging labels and the SecretVersionId attached to each one.

Staging labels are used to keep track of the different versions during the rotation process.

field Tags: builtins.list[Tag] | None [Optional]

The list of user-defined tags associated with the secret.

To add tags to a secret, use `TagResource <https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_TagResource.html>`_ . To remove tags, use `UntagResource <https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_UntagResource.html>`_ .

field Type: str | None = None

The exact string that identifies the third-party partner that holds the external secret.

For more information, see Managed external secret partners.

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 SecretManager

tag_class: alias of Tag

delete(): Delete the model.

get_value(VersionId: str | None = None, VersionStage: str | None = None) → GetSecretValueResponse[source]

Get the value of the secret.

Keyword Arguments:

VersionId – The unique identifier of the version of the secret to retrieve. If you include both this parameter and VersionStage, the two parameters must refer to the same secret version. If you don’t specify either a VersionStage or VersionId, then Secrets Manager returns the AWSCURRENT version.
VersionStage – The staging label of the version of the secret to retrieve.

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.

Set the value of the secret.

Keyword Arguments:

ClientRequestToken – A unique identifier for the new version of the secret.
SecretBinary – The binary data to encrypt and store in the new version of the secret. To use this parameter in the command-line tools, we recommend that you store your binary data in a file and then pass the contents of the file as a parameter.
SecretString – The text to encrypt and store in the new version of the secret.
VersionStages – A list of staging labels to attach to this version of the secret. Secrets Manager uses staging labels to track versions of a secret through the rotation process.
RotationToken – A unique identifier that indicates the source of the request. Required for secret rotations using an IAM assumed role or cross-account rotation, in which you rotate a secret in one account by using a Lambda rotation function in another account. In both cases, the rotation function assumes an IAM role to call Secrets Manager, and then Secrets Manager validates the identity using the token. For more information, see How rotation works and Rotation by Lambda functions.

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 ARN attribute.

Returns:: The ARN of the model instance.

property name: str | None

Return the name of the model. This is the value of the Name 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 ARN attribute.

Returns:: The primary key of the model instance.

property tags: TagsDict

Get the tags for the model instance.

Returns:: The tags for the model instance.

pydantic model botocraft.services.secretsmanager.SecretVersion[source]

Bases: PrimaryBoto3Model

A structure that contains information about one version of a secret.

Show JSON schema

{
   "title": "SecretVersion",
   "description": "A structure that contains information about one version of a secret.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "VersionId": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Versionid"
      },
      "VersionStages": {
         "anyOf": [
            {
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Versionstages"
      },
      "LastAccessedDate": {
         "anyOf": [
            {
               "format": "date-time",
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Lastaccesseddate"
      },
      "CreatedDate": {
         "anyOf": [
            {
               "format": "date-time",
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Createddate"
      },
      "KmsKeyIds": {
         "anyOf": [
            {
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Kmskeyids"
      }
   }
}

Config:

validate_assignment: bool = True
arbitrary_types_allowed: bool = True

Fields:

CreatedDate (datetime.datetime | None)
KmsKeyIds (list[str] | None)
LastAccessedDate (datetime.datetime | None)
VersionId (str | None)
VersionStages (list[str] | None)
session (Any | None)

field CreatedDate: datetime | None = None: The date and time this version of the secret was created.

field KmsKeyIds: builtins.list[str] | None [Optional]: The KMS keys used to encrypt the secret version.

field LastAccessedDate: datetime | None = None

The date that this version of the secret was last accessed.

Note that the resolution of this field is at the date level and does not include the time.

field VersionId: str | None = None: The unique version identifier of this version of the secret.

field VersionStages: builtins.list[str] | None [Optional]: An array of staging labels that are currently associated with this version of the secret.

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 SecretVersionManager

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

Get the ARN of the model instance.

Returns:: The ARN of the model instance.
Raises:: ValueError – If the model has no ARN identity field.

property name: str | None

Return the name of the model. This is the value of the VersionId 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 VersionId 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.secretsmanager.SecretManager[source]

Bases: Boto3ModelManager

cancel_rotation(SecretId: str) → CancelRotateSecretResponse[source]

Turns off automatic rotation, and if a rotation is currently in progress, cancels the rotation.

Parameters:: SecretId – The ARN or name of the secret.

create(model: Secret, ClientRequestToken: str | None = None, SecretBinary: bytes | None = None, SecretString: str | None = None, AddReplicaRegions: list[botocraft.services.secretsmanager.ReplicaRegionType] | None = None) → CreateSecretResponse[source]

Creates a new secret. A secret can be a password, a set of credentials such as a user name and password, an OAuth token, or other secret information that you store in an encrypted form in Secrets Manager. The secret also includes the connection information to access a database or other service, which Secrets Manager doesn’t encrypt. A secret in Secrets Manager consists of both the protected secret data and the important information needed to manage the secret.

Parameters:

model – The SecretListEntry to create.

Keyword Arguments:

ClientRequestToken – If you include SecretString or SecretBinary, then Secrets Manager creates an initial version for the secret, and this parameter specifies the unique identifier for the new version.
SecretBinary – The binary data to encrypt and store in the new version of the secret. We recommend that you store your binary data in a file and then pass the contents of the file as a parameter.
SecretString – The text data to encrypt and store in this new version of the secret. We recommend you use a JSON structure of key/value pairs for your secret value.
AddReplicaRegions – A list of Regions and KMS keys to replicate secrets.

delete(SecretId: str, *, RecoveryWindowInDays: int | None = None, ForceDeleteWithoutRecovery: bool | None = None) → Secret[source]

Deletes a secret and all of its versions. You can specify a recovery window during which you can restore the secret. The minimum recovery window is 7 days. The default recovery window is 30 days. Secrets Manager attaches a DeletionDate stamp to the secret that specifies the end of the recovery window. At the end of the recovery window, Secrets Manager deletes the secret permanently.

Parameters:

SecretId – The ARN or name of the secret to delete.

Keyword Arguments:

RecoveryWindowInDays – The number of days from 7 to 30 that Secrets Manager waits before permanently deleting the secret. You can’t use both this parameter and ForceDeleteWithoutRecovery in the same call. If you don’t use either, then by default Secrets Manager uses a 30 day recovery window.
ForceDeleteWithoutRecovery – Specifies whether to delete the secret without any recovery window. You can’t use both this parameter and RecoveryWindowInDays in the same call. If you don’t use either, then by default Secrets Manager uses a 30 day recovery window.

delete_resource_policy(SecretId: str) → DeleteResourcePolicyResponse[source]

Deletes the resource-based permission policy attached to the secret. To attach a policy to a secret, use PutResourcePolicy.

Parameters:: SecretId – The ARN or name of the secret to delete the attached resource-based policy for.

get(SecretId: str) → Secret | None[source]

Retrieves the details of a secret. It does not include the encrypted secret value. Secrets Manager only returns fields that have a value in the response.

Parameters:: SecretId – The ARN or name of the secret.

get_resource_policy(SecretId: str) → GetResourcePolicyResponse[source]

Retrieves the JSON text of the resource-based policy document attached to the secret. For more information about permissions policies attached to a secret, see Permissions policies attached to a secret.

Parameters:: SecretId – The ARN or name of the secret to retrieve the attached resource-based policy for.

get_value(SecretId: str, *, VersionId: str | None = None, VersionStage: str | None = None) → GetSecretValueResponse[source]

Retrieves the contents of the encrypted fields SecretString or SecretBinary from the specified version of a secret, whichever contains content.

Parameters:

SecretId – The ARN or name of the secret to retrieve. To retrieve a secret from another account, you must use an ARN.

Keyword Arguments:

VersionId – The unique identifier of the version of the secret to retrieve. If you include both this parameter and VersionStage, the two parameters must refer to the same secret version. If you don’t specify either a VersionStage or VersionId, then Secrets Manager returns the AWSCURRENT version.
VersionStage – The staging label of the version of the secret to retrieve.

list(*, IncludePlannedDeletion: bool | None = None, Filters: list[botocraft.services.secretsmanager.SecretsFilter] | None = None, SortOrder: Literal['asc', 'desc'] | None = None, SortBy: Literal['created-date', 'last-accessed-date', 'last-changed-date', 'name'] | None = None) → list[botocraft.services.secretsmanager.Secret][source]

Lists the secrets that are stored by Secrets Manager in the Amazon Web Services account, not including secrets that are marked for deletion. To see secrets marked for deletion, use the Secrets Manager console.

Keyword Arguments:

IncludePlannedDeletion – Specifies whether to include secrets scheduled for deletion. By default, secrets scheduled for deletion aren’t included.
Filters – The filters to apply to the list of secrets.
SortOrder – Secrets are listed by CreatedDate.
SortBy – If not specified, secrets are listed by CreatedDate.

Generates a random password. We recommend that you specify the maximum length and include every character type that the system you are generating a password for can support. By default, Secrets Manager uses uppercase and lowercase letters, numbers, and the following characters in passwords: ```` !”#$%&’()*+,-./:;<=>?@[]^_``{|}~ ````

Keyword Arguments:

PasswordLength – The length of the password. If you don’t include this parameter, the default length is 32 characters.
ExcludeCharacters – A string of the characters that you don’t want in the password.
ExcludeNumbers – Specifies whether to exclude numbers from the password. If you don’t include this switch, the password can contain numbers.
ExcludePunctuation – Specifies whether to exclude the following punctuation characters from the password: ```` ! “ # $ % & ‘ ( ) * + , - . / : ; < = > ? @ [ ] ^ _ `` { | } ~ ````. If you don’t include this switch, the password can contain punctuation.
ExcludeUppercase – Specifies whether to exclude uppercase letters from the password. If you don’t include this switch, the password can contain uppercase letters.
ExcludeLowercase – Specifies whether to exclude lowercase letters from the password. If you don’t include this switch, the password can contain lowercase letters.
IncludeSpace – Specifies whether to include the space character. If you include this switch, the password can contain space characters.
RequireEachIncludedType – Specifies whether to include at least one upper and lowercase letter, one number, and one punctuation. If you don’t include this switch, the password contains at least one of every character type.

restore(SecretId: str) → RestoreSecretResponse[source]

Cancels the scheduled deletion of a secret by removing the DeletedDate time stamp. You can access a secret again after it has been restored.

Parameters:: SecretId – The ARN or name of the secret to restore.

rotate(SecretId: str, *, ClientRequestToken: str | None = None, RotationLambdaARN: str | None = None, RotationRules: RotationRulesType | None = None, ExternalSecretRotationMetadata: list[botocraft.services.secretsmanager.ExternalSecretRotationMetadataItem] | None = None, ExternalSecretRotationRoleArn: str | None = None, RotateImmediately: bool | None = None) → RotateSecretResponse[source]

Configures and starts the asynchronous process of rotating the secret. For information about rotation, see Rotate secrets in the Secrets Manager User Guide. If you include the configuration parameters, the operation sets the values for the secret and then immediately starts a rotation. If you don’t include the configuration parameters, the operation starts a rotation with the values already stored in the secret.

Parameters:

SecretId – The ARN or name of the secret to rotate.

Keyword Arguments:

ClientRequestToken – A unique identifier for the new version of the secret. You only need to specify this value if you implement your own retry logic and you want to ensure that Secrets Manager doesn’t attempt to create a secret version twice.
RotationLambdaARN – For secrets that use a Lambda rotation function to rotate, the ARN of the Lambda rotation function.
RotationRules – A structure that defines the rotation configuration for this secret.
ExternalSecretRotationMetadata – The metadata needed to successfully rotate a managed external secret. A list of key value pairs in JSON format specified by the partner. For more information about the required information, see Using Secrets Manager managed external secrets
ExternalSecretRotationRoleArn – The Amazon Resource Name (ARN) of the role that allows Secrets Manager to rotate a secret held by a third-party partner. For more information, see Security and permissions.
RotateImmediately – Specifies whether to rotate the secret immediately or wait until the next scheduled rotation window. The rotation schedule is defined in RotateSecretRequest$RotationRules.

set_resource_policy(SecretId: str, ResourcePolicy: str, *, BlockPublicPolicy: bool | None = None) → PutResourcePolicyResponse[source]

Attaches a resource-based permission policy to a secret. A resource-based policy is optional. For more information, see Authentication and access control for Secrets Manager

Parameters:

SecretId – The ARN or name of the secret to attach the resource-based policy.
ResourcePolicy – A JSON-formatted string for an Amazon Web Services resource-based policy. For example policies, see Permissions policy examples.

Keyword Arguments:

BlockPublicPolicy – Specifies whether to block resource-based policies that allow broad access to the secret, for example those that use a wildcard for the principal. By default, public policies aren’t blocked.

Creates a new version of your secret by creating a new encrypted value and attaching it to the secret. version can contain a new SecretString value or a new SecretBinary value.

Parameters:

SecretId – The ARN or name of the secret to add a new version to.

Keyword Arguments:

ClientRequestToken – A unique identifier for the new version of the secret.
SecretBinary – The binary data to encrypt and store in the new version of the secret. To use this parameter in the command-line tools, we recommend that you store your binary data in a file and then pass the contents of the file as a parameter.
SecretString – The text to encrypt and store in the new version of the secret.
VersionStages – A list of staging labels to attach to this version of the secret. Secrets Manager uses staging labels to track versions of a secret through the rotation process.
RotationToken –
A unique identifier that indicates the source of the request. Required for secret rotations using an IAM assumed role or cross-account rotation, in which you rotate a secret in one account by using a Lambda rotation function in another account. In both cases, the rotation function assumes an IAM role to call Secrets Manager, and then Secrets Manager validates the identity using the token. For more information, see How rotation works and Rotation by Lambda functions.

update(model: Secret, SecretId: str, ClientRequestToken: str | None = None, SecretBinary: bytes | None = None, SecretString: str | None = None) → UpdateSecretResponse[source]

Modifies the details of a secret, including metadata and the secret value. To change the secret value, you can also use PutSecretValue.

Parameters:

model – The SecretListEntry to update.
SecretId – The ARN or name of the secret.

Keyword Arguments:

ClientRequestToken – If you include SecretString or SecretBinary, then Secrets Manager creates a new version for the secret, and this parameter specifies the unique identifier for the new version.
SecretBinary – The binary data to encrypt and store in the new version of the secret. We recommend that you store your binary data in a file and then pass the contents of the file as a parameter.
SecretString – The text data to encrypt and store in the new version of the secret. We recommend you use a JSON structure of key/value pairs for your secret value.

update_version_stage(SecretId: str, VersionStage: str, *, RemoveFromVersionId: str | None = None, MoveToVersionId: str | None = None) → UpdateSecretVersionStageResponse[source]

Modifies the staging labels attached to a version of a secret. Secrets Manager uses staging labels to track a version as it progresses through the secret rotation process. Each staging label can be attached to only one version at a time. To add a staging label to a version when it is already attached to another version, Secrets Manager first removes it from the other version first and then attaches it to this one. For more information about versions and staging labels, see Concepts: Version.

Parameters:

SecretId – The ARN or the name of the secret with the version and staging labelsto modify.
VersionStage – The staging label to add to this version.

Keyword Arguments:

RemoveFromVersionId – The ID of the version that the staging label is to be removed from. If the staging label you are trying to attach to one version is already attached to a different version, then you must include this parameter and specify the version that the label is to be removed from. If the label is attached and you either do not specify this parameter, or the version ID does not match, then the operation fails.
MoveToVersionId – The ID of the version to add the staging label to. To remove a label from a version, then do not specify this parameter.

service_name: str = 'secretsmanager'

ec2, s3, etc.

Type:: The name of the boto3 service. Example

class botocraft.services.secretsmanager.SecretVersionManager[source]

Bases: Boto3ModelManager

list(SecretId: str, *, MaxResults: int | None = None, NextToken: str | None = None, IncludeDeprecated: bool | None = None) → PrimaryBoto3ModelQuerySet[source]

Lists the versions of a secret. Secrets Manager uses staging labels to indicate the different versions of a secret. For more information, see Secrets Manager concepts: Versions.

Parameters:

SecretId – The ARN or name of the secret whose versions you want to list.

Keyword Arguments:

MaxResults – The number of results to include in the response.
NextToken – A token that indicates where the output should continue from, if a previous call did not show all results. To get the next results, call ListSecretVersionIds again with this value.
IncludeDeprecated – Specifies whether to include versions of secrets that don’t have any staging labels attached to them. Versions without staging labels are considered deprecated and are subject to deletion by Secrets Manager. By default, versions without staging labels aren’t included.

service_name: str = 'secretsmanager'

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.

pydantic model botocraft.services.secretsmanager.ExternalSecretRotationMetadataItem[source]

Bases: Boto3Model

The metadata needed to successfully rotate a managed external secret.

A list of key value pairs in JSON format specified by the partner. For more information, see Managed external secret partners.

Show JSON schema

{
   "title": "ExternalSecretRotationMetadataItem",
   "description": "The metadata needed to successfully rotate a managed external secret.\n\nA list of key value pairs in JSON format specified by the partner. For more\ninformation, see\n`Managed external secret partners <https://docs.aws.amazon.com/secretsmanager/latest/userguide/mes-partners.html>`_.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "Key": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Key"
      },
      "Value": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Value"
      }
   }
}

Config:

validate_assignment: bool = True
arbitrary_types_allowed: bool = True

Fields:

Key (str | None)
Value (str | None)
session (Any | None)

field Key: str | None = None: The key that identifies the item.

field Value: str | None = None: The value of the specified item.

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.secretsmanager.RotationRulesType[source]

Bases: Boto3Model

A structure that defines the rotation configuration for the secret.

Show JSON schema

{
   "title": "RotationRulesType",
   "description": "A structure that defines the rotation configuration for the secret.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "AutomaticallyAfterDays": {
         "anyOf": [
            {
               "type": "integer"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Automaticallyafterdays"
      },
      "Duration": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Duration"
      },
      "ScheduleExpression": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Scheduleexpression"
      }
   }
}

Config:

validate_assignment: bool = True
arbitrary_types_allowed: bool = True

Fields:

AutomaticallyAfterDays (int | None)
Duration (str | None)
ScheduleExpression (str | None)
session (Any | None)

field AutomaticallyAfterDays: int | None = None

The number of days between rotations of the secret.

You can use this value to check that your secret meets your compliance guidelines for how often secrets must be rotated. If you use this field to set the rotation schedule, Secrets Manager calculates the next rotation date based on the previous rotation. Manually updating the secret value by calling PutSecretValue or UpdateSecret is considered a valid rotation.

field Duration: str | None = None

The length of the rotation window in hours, for example 3h for a three hour window.

Secrets Manager rotates your secret at any time during this window. The window must not extend into the next rotation window or the next UTC day. The window starts according to the ScheduleExpression. If you don’t specify a Duration, for a ScheduleExpression in hours, the window automatically closes after one hour. For a ScheduleExpression in days, the window automatically closes at the end of the UTC day. For more information, including examples, see Schedule expressions in Secrets Manager rotation in the Secrets Manager Users Guide.

field ScheduleExpression: str | None = None

A cron() or rate() expression that defines the schedule for rotating your secret.

Secrets Manager rotation schedules use UTC time zone. Secrets Manager rotates your secret any time during a rotation window.

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.

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.secretsmanager.CancelRotateSecretResponse[source]

Bases: Boto3Model

Show JSON schema

{
   "title": "CancelRotateSecretResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "ARN": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Arn"
      },
      "Name": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Name"
      },
      "VersionId": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Versionid"
      }
   }
}

Config:

validate_assignment: bool = True
arbitrary_types_allowed: bool = True

Fields:

ARN (str | None)
Name (str | None)
VersionId (str | None)
session (Any | None)

field ARN: str | None = None: The ARN of the secret.

field Name: str | None = None: The name of the secret.

field VersionId: str | None = None

The unique identifier of the version of the secret created during the rotation.

This version might not be complete, and should be evaluated for possible deletion. We recommend that you remove the VersionStage value AWSPENDING from this version so that Secrets Manager can delete it. Failing to clean up a cancelled rotation can block you from starting future rotations.

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.secretsmanager.CreateSecretResponse[source]

Bases: Boto3Model

Show JSON schema

{
   "title": "CreateSecretResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "ARN": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Arn"
      },
      "Name": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Name"
      },
      "VersionId": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Versionid"
      },
      "ReplicationStatus": {
         "anyOf": [
            {
               "items": {
                  "$ref": "#/$defs/ReplicationStatusType"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Replicationstatus"
      }
   },
   "$defs": {
      "ReplicationStatusType": {
         "description": "A replication object consisting of a ``RegionReplicationStatus`` object and includes\na Region, KMSKeyId, status, and status message.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Region": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Region"
            },
            "KmsKeyId": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Kmskeyid"
            },
            "Status": {
               "anyOf": [
                  {
                     "enum": [
                        "InSync",
                        "Failed",
                        "InProgress"
                     ],
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Status"
            },
            "StatusMessage": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Statusmessage"
            },
            "LastAccessedDate": {
               "anyOf": [
                  {
                     "format": "date-time",
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Lastaccesseddate"
            }
         },
         "title": "ReplicationStatusType",
         "type": "object"
      }
   }
}

Config:

validate_assignment: bool = True
arbitrary_types_allowed: bool = True

Fields:

ARN (str | None)
Name (str | None)
ReplicationStatus (list[botocraft.services.secretsmanager.ReplicationStatusType] | None)
VersionId (str | None)
session (Any | None)

field ARN: str | None = None

The ARN of the new secret.

The ARN includes the name of the secret followed by six random characters. This ensures that if you create a new secret with the same name as a deleted secret, then users with access to the old secret don’t get access to the new secret because the ARNs are different.

field Name: str | None = None: The name of the new secret.

field ReplicationStatus: builtins.list[ReplicationStatusType] | None [Optional]: A list of the replicas of this secret and their status:

field VersionId: str | None = None: The unique identifier associated with the version of the new secret.

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.secretsmanager.DeleteResourcePolicyResponse[source]

Bases: Boto3Model

Show JSON schema

{
   "title": "DeleteResourcePolicyResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "ARN": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Arn"
      },
      "Name": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Name"
      }
   }
}

Config:

validate_assignment: bool = True
arbitrary_types_allowed: bool = True

Fields:

ARN (str | None)
Name (str | None)
session (Any | None)

field ARN: str | None = None: The ARN of the secret that the resource-based policy was deleted for.

field Name: str | None = None: The name of the secret that the resource-based policy was deleted for.

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.secretsmanager.DeleteSecretResponse[source]

Bases: Boto3Model

Show JSON schema

{
   "title": "DeleteSecretResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "ARN": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Arn"
      },
      "Name": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Name"
      },
      "DeletionDate": {
         "anyOf": [
            {
               "format": "date-time",
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Deletiondate"
      }
   }
}

Config:

validate_assignment: bool = True
arbitrary_types_allowed: bool = True

Fields:

ARN (str | None)
DeletionDate (datetime.datetime | None)
Name (str | None)
session (Any | None)

field ARN: str | None = None: The ARN of the secret.

field DeletionDate: datetime | None = None

The date and time after which this secret Secrets Manager can permanently delete this secret, and it can no longer be restored.

This value is the date and time of the delete request plus the number of days in RecoveryWindowInDays.

field Name: str | None = None: The name of the secret.

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.secretsmanager.DescribeSecretResponse[source]

Bases: TagsDictMixin, Boto3Model

Show JSON schema

{
   "title": "DescribeSecretResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "ARN": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Arn"
      },
      "Name": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Name"
      },
      "Type": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Type"
      },
      "Description": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Description"
      },
      "KmsKeyId": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Kmskeyid"
      },
      "RotationEnabled": {
         "anyOf": [
            {
               "type": "boolean"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Rotationenabled"
      },
      "RotationLambdaARN": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Rotationlambdaarn"
      },
      "RotationRules": {
         "anyOf": [
            {
               "$ref": "#/$defs/RotationRulesType"
            },
            {
               "type": "null"
            }
         ],
         "default": null
      },
      "ExternalSecretRotationMetadata": {
         "anyOf": [
            {
               "items": {
                  "$ref": "#/$defs/ExternalSecretRotationMetadataItem"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Externalsecretrotationmetadata"
      },
      "ExternalSecretRotationRoleArn": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Externalsecretrotationrolearn"
      },
      "LastRotatedDate": {
         "anyOf": [
            {
               "format": "date-time",
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Lastrotateddate"
      },
      "LastChangedDate": {
         "anyOf": [
            {
               "format": "date-time",
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Lastchangeddate"
      },
      "LastAccessedDate": {
         "anyOf": [
            {
               "format": "date-time",
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Lastaccesseddate"
      },
      "DeletedDate": {
         "anyOf": [
            {
               "format": "date-time",
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Deleteddate"
      },
      "NextRotationDate": {
         "anyOf": [
            {
               "format": "date-time",
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Nextrotationdate"
      },
      "Tags": {
         "anyOf": [
            {
               "items": {
                  "$ref": "#/$defs/Tag"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Tags"
      },
      "VersionIdsToStages": {
         "anyOf": [
            {
               "additionalProperties": {
                  "items": {
                     "type": "string"
                  },
                  "type": "array"
               },
               "type": "object"
            },
            {
               "type": "null"
            }
         ],
         "title": "Versionidstostages"
      },
      "OwningService": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Owningservice"
      },
      "CreatedDate": {
         "anyOf": [
            {
               "format": "date-time",
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Createddate"
      },
      "PrimaryRegion": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Primaryregion"
      },
      "ReplicationStatus": {
         "anyOf": [
            {
               "items": {
                  "$ref": "#/$defs/ReplicationStatusType"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Replicationstatus"
      }
   },
   "$defs": {
      "ExternalSecretRotationMetadataItem": {
         "description": "The metadata needed to successfully rotate a managed external secret.\n\nA list of key value pairs in JSON format specified by the partner. For more\ninformation, see\n`Managed external secret partners <https://docs.aws.amazon.com/secretsmanager/latest/userguide/mes-partners.html>`_.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Key": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Key"
            },
            "Value": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Value"
            }
         },
         "title": "ExternalSecretRotationMetadataItem",
         "type": "object"
      },
      "ReplicationStatusType": {
         "description": "A replication object consisting of a ``RegionReplicationStatus`` object and includes\na Region, KMSKeyId, status, and status message.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Region": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Region"
            },
            "KmsKeyId": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Kmskeyid"
            },
            "Status": {
               "anyOf": [
                  {
                     "enum": [
                        "InSync",
                        "Failed",
                        "InProgress"
                     ],
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Status"
            },
            "StatusMessage": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Statusmessage"
            },
            "LastAccessedDate": {
               "anyOf": [
                  {
                     "format": "date-time",
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Lastaccesseddate"
            }
         },
         "title": "ReplicationStatusType",
         "type": "object"
      },
      "RotationRulesType": {
         "description": "A structure that defines the rotation configuration for the secret.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "AutomaticallyAfterDays": {
               "anyOf": [
                  {
                     "type": "integer"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Automaticallyafterdays"
            },
            "Duration": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Duration"
            },
            "ScheduleExpression": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Scheduleexpression"
            }
         },
         "title": "RotationRulesType",
         "type": "object"
      },
      "Tag": {
         "description": "The metadata that you apply to a resource to help you categorize and\norganize them. Each tag consists of a key and an optional value. You define\nthem.\n\nThe following basic restrictions apply to tags:\n\n* Maximum number of tags per resource - 50\n* For each resource, each tag key must be unique, and each tag key can have\n  only one value.\n* Maximum key length - 128 Unicode characters in UTF-8\n* Maximum value length - 256 Unicode characters in UTF-8\n* If your tagging schema is used across multiple services and resources,\n  remember that other services may have restrictions on allowed characters.\n  Generally allowed characters are: letters, numbers, and spaces representable in\n  UTF-8, and the following characters: + - = . _ : / @.\n* Tag keys and values are case-sensitive.\n* Do not use ``aws:``, ``AWS:``, or any upper or lowercase combination of such\n  as a prefix for either keys or values as it is reserved for Amazon Web Services\n  use. You cannot edit or delete tag keys or values with this prefix. Tags with\n  this prefix do not count against your tags per resource limit.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Key": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Key"
            },
            "Value": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Value"
            }
         },
         "title": "Tag",
         "type": "object"
      }
   }
}

Config:

validate_assignment: bool = True
arbitrary_types_allowed: bool = True

Fields:

ARN (str | None)
CreatedDate (datetime.datetime | None)
DeletedDate (datetime.datetime | None)
Description (str | None)
ExternalSecretRotationMetadata (list[botocraft.services.secretsmanager.ExternalSecretRotationMetadataItem] | None)
ExternalSecretRotationRoleArn (str | None)
KmsKeyId (str | None)
LastAccessedDate (datetime.datetime | None)
LastChangedDate (datetime.datetime | None)
LastRotatedDate (datetime.datetime | None)
Name (str | None)
NextRotationDate (datetime.datetime | None)
OwningService (str | None)
PrimaryRegion (str | None)
ReplicationStatus (list[botocraft.services.secretsmanager.ReplicationStatusType] | None)
RotationEnabled (bool | None)
RotationLambdaARN (str | None)
RotationRules (botocraft.services.secretsmanager.RotationRulesType | None)
Tags (list[botocraft.services.common.Tag] | None)
Type (str | None)
VersionIdsToStages (dict[str, list[str]] | None)
session (Any | None)

field ARN: str | None = None: The ARN of the secret.

field CreatedDate: datetime | None = None: The date the secret was created.

field DeletedDate: datetime | None = None

The date the secret is scheduled for deletion.

If it is not scheduled for deletion, this field is omitted. When you delete a secret, Secrets Manager requires a recovery window of at least 7 days before deleting the secret. Some time after the deleted date, Secrets Manager deletes the secret, including all of its versions.

field Description: str | None = None: The description of the secret.

field ExternalSecretRotationMetadata: builtins.list[ExternalSecretRotationMetadataItem] | None [Optional]

The metadata needed to successfully rotate a managed external secret.

A list of key value pairs in JSON format specified by the partner. For more information about the required information, see Managed external secrets partners.

field ExternalSecretRotationRoleArn: str | None = None

The Amazon Resource Name (ARN) of the role that allows Secrets Manager to rotate a secret held by a third-party partner.

For more information, see Security and permissions.

field KmsKeyId: str | None = None

The key ID or alias ARN of the KMS key that Secrets Manager uses to encrypt the secret value.

If the secret is encrypted with the Amazon Web Services managed key aws/secretsmanager, this field is omitted. Secrets created using the console use an KMS key ID.

field LastAccessedDate: datetime | None = None

The date that the secret was last accessed in the Region.

This field is omitted if the secret has never been retrieved in the Region.

field LastChangedDate: datetime | None = None: The last date and time that this secret was modified in any way.

field LastRotatedDate: datetime | None = None

The last date and time that Secrets Manager rotated the secret.

If the secret isn’t configured for rotation or rotation has been disabled, Secrets Manager returns null.

field Name: str | None = None: The name of the secret.

field NextRotationDate: datetime | None = None

The next rotation is scheduled to occur on or before this date.

If the secret isn’t configured for rotation or rotation has been disabled, Secrets Manager returns null. If rotation fails, Secrets Manager retries the entire rotation process multiple times. If rotation is unsuccessful, this date may be in the past.

field OwningService: str | None = None

The ID of the service that created this secret.

For more information, see Secrets managed by other Amazon Web Services services.

field PrimaryRegion: str | None = None

The Region the secret is in.

If a secret is replicated to other Regions, the replicas are listed in ReplicationStatus.

field ReplicationStatus: builtins.list[ReplicationStatusType] | None [Optional]: A list of the replicas of this secret and their status:

field RotationEnabled: bool | None = None

Specifies whether automatic rotation is turned on for this secret.

If the secret has never been configured for rotation, Secrets Manager returns null.

field RotationLambdaARN: str | None = None: The ARN of the Lambda function that Secrets Manager invokes to rotate the secret.

field RotationRules: RotationRulesType | None = None

The rotation schedule and Lambda function for this secret.

If the secret previously had rotation turned on, but it is now turned off, this field shows the previous rotation schedule and rotation function. If the secret never had rotation turned on, this field is omitted.

field Tags: builtins.list[Tag] | None [Optional]

The list of tags attached to the secret.

To add tags to a secret, use TagResource. To remove tags, use UntagResource.

field Type: str | None = None

The exact string that identifies the partner that holds the external secret.

For more information, see Using Secrets Manager managed external secrets.

field VersionIdsToStages: dict[str, builtins.list[str]] | None [Optional]

A list of the versions of the secret that have staging labels attached.

Versions that don’t have staging labels are considered deprecated and Secrets Manager can delete them.

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.

tag_class: alias of Tag

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.

property tags: TagsDict

Get the tags for the model instance.

Returns:: The tags for the model instance.

pydantic model botocraft.services.secretsmanager.GetRandomPasswordResponse[source]

Bases: Boto3Model

Show JSON schema

{
   "title": "GetRandomPasswordResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "RandomPassword": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Randompassword"
      }
   }
}

Config:

validate_assignment: bool = True
arbitrary_types_allowed: bool = True

Fields:

RandomPassword (str | None)
session (Any | None)

field RandomPassword: str | None = None: A string with the password.

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.secretsmanager.GetResourcePolicyResponse[source]

Bases: Boto3Model

Show JSON schema

{
   "title": "GetResourcePolicyResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "ARN": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Arn"
      },
      "Name": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Name"
      },
      "ResourcePolicy": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Resourcepolicy"
      }
   }
}

Config:

validate_assignment: bool = True
arbitrary_types_allowed: bool = True

Fields:

ARN (str | None)
Name (str | None)
ResourcePolicy (str | None)
session (Any | None)

field ARN: str | None = None: The ARN of the secret that the resource-based policy was retrieved for.

field Name: str | None = None: The name of the secret that the resource-based policy was retrieved for.

field ResourcePolicy: str | None = None

A JSON-formatted string that contains the permissions policy attached to the secret.

For more information about permissions policies, see Authentication and access control for Secrets Manager.

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.secretsmanager.GetSecretValueResponse[source]

Bases: Boto3Model

Show JSON schema

{
   "title": "GetSecretValueResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "ARN": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Arn"
      },
      "Name": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Name"
      },
      "VersionId": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Versionid"
      },
      "SecretBinary": {
         "anyOf": [
            {
               "format": "binary",
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Secretbinary"
      },
      "SecretString": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Secretstring"
      },
      "VersionStages": {
         "anyOf": [
            {
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Versionstages"
      },
      "CreatedDate": {
         "anyOf": [
            {
               "format": "date-time",
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Createddate"
      }
   }
}

Config:

validate_assignment: bool = True
arbitrary_types_allowed: bool = True

Fields:

ARN (str | None)
CreatedDate (datetime.datetime | None)
Name (str | None)
SecretBinary (bytes | None)
SecretString (str | None)
VersionId (str | None)
VersionStages (list[str] | None)
session (Any | None)

field ARN: str | None = None: The ARN of the secret.

field CreatedDate: datetime | None = None

The date and time that this version of the secret was created.

If you don’t specify which version in VersionId or VersionStage, then Secrets Manager uses the AWSCURRENT version.

field Name: str | None = None: The friendly name of the secret.

field SecretBinary: bytes | None = None

The decrypted secret value, if the secret value was originally provided as binary data in the form of a byte array.

When you retrieve a SecretBinary using the HTTP API, the Python SDK, or the Amazon Web Services CLI, the value is Base64-encoded. Otherwise, it is not encoded.

field SecretString: str | None = None: The decrypted secret value, if the secret value was originally provided as a string or through the Secrets Manager console.

field VersionId: str | None = None: The unique identifier of this version of the secret.

field VersionStages: builtins.list[str] | None [Optional]: A list of all of the staging labels currently attached to this version of the secret.

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.secretsmanager.ListSecretVersionIdsResponse[source]

Bases: Boto3Model

Show JSON schema

{
   "title": "ListSecretVersionIdsResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "Versions": {
         "anyOf": [
            {
               "items": {
                  "$ref": "#/$defs/SecretVersion"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Versions"
      },
      "NextToken": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Nexttoken"
      },
      "ARN": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Arn"
      },
      "Name": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Name"
      }
   },
   "$defs": {
      "SecretVersion": {
         "description": "A structure that contains information about one version of a secret.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "VersionId": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Versionid"
            },
            "VersionStages": {
               "anyOf": [
                  {
                     "items": {
                        "type": "string"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Versionstages"
            },
            "LastAccessedDate": {
               "anyOf": [
                  {
                     "format": "date-time",
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Lastaccesseddate"
            },
            "CreatedDate": {
               "anyOf": [
                  {
                     "format": "date-time",
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Createddate"
            },
            "KmsKeyIds": {
               "anyOf": [
                  {
                     "items": {
                        "type": "string"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Kmskeyids"
            }
         },
         "title": "SecretVersion",
         "type": "object"
      }
   }
}

Config:

validate_assignment: bool = True
arbitrary_types_allowed: bool = True

Fields:

ARN (str | None)
Name (str | None)
NextToken (str | None)
Versions (list[botocraft.services.secretsmanager.SecretVersion] | None)
session (Any | None)

field ARN: str | None = None: The ARN of the secret.

field Name: str | None = None: The name of the secret.

field NextToken: str | None = None

Secrets Manager includes this value if there’s more output available than what is included in the current response.

This can occur even when the response includes no values at all, such as when you ask for a filtered view of a long list. To get the next results, call ListSecretVersionIds again with this value.

field Versions: builtins.list[SecretVersion] | None [Optional]: A list of the versions of the secret.

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.secretsmanager.ListSecretsResponse[source]

Bases: Boto3Model

Show JSON schema

{
   "title": "ListSecretsResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "SecretList": {
         "anyOf": [
            {
               "items": {
                  "$ref": "#/$defs/Secret"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Secretlist"
      },
      "NextToken": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Nexttoken"
      }
   },
   "$defs": {
      "ExternalSecretRotationMetadataItem": {
         "description": "The metadata needed to successfully rotate a managed external secret.\n\nA list of key value pairs in JSON format specified by the partner. For more\ninformation, see\n`Managed external secret partners <https://docs.aws.amazon.com/secretsmanager/latest/userguide/mes-partners.html>`_.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Key": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Key"
            },
            "Value": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Value"
            }
         },
         "title": "ExternalSecretRotationMetadataItem",
         "type": "object"
      },
      "RotationRulesType": {
         "description": "A structure that defines the rotation configuration for the secret.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "AutomaticallyAfterDays": {
               "anyOf": [
                  {
                     "type": "integer"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Automaticallyafterdays"
            },
            "Duration": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Duration"
            },
            "ScheduleExpression": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Scheduleexpression"
            }
         },
         "title": "RotationRulesType",
         "type": "object"
      },
      "Secret": {
         "description": "A structure that contains the details about a secret.\n\nIt does not include the encrypted ``SecretString`` and\n``SecretBinary`` values. To get those values, use\n`GetSecretValue <https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html>`_ .",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Name": {
               "title": "Name",
               "type": "string"
            },
            "ARN": {
               "default": null,
               "title": "Arn",
               "type": "string"
            },
            "Type": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Type"
            },
            "Description": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Description"
            },
            "KmsKeyId": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Kmskeyid"
            },
            "RotationEnabled": {
               "default": null,
               "title": "Rotationenabled",
               "type": "boolean"
            },
            "RotationLambdaARN": {
               "default": null,
               "title": "Rotationlambdaarn",
               "type": "string"
            },
            "RotationRules": {
               "$ref": "#/$defs/RotationRulesType",
               "default": null
            },
            "ExternalSecretRotationMetadata": {
               "items": {
                  "$ref": "#/$defs/ExternalSecretRotationMetadataItem"
               },
               "title": "Externalsecretrotationmetadata",
               "type": "array"
            },
            "ExternalSecretRotationRoleArn": {
               "default": null,
               "title": "Externalsecretrotationrolearn",
               "type": "string"
            },
            "LastRotatedDate": {
               "default": null,
               "format": "date-time",
               "title": "Lastrotateddate",
               "type": "string"
            },
            "LastChangedDate": {
               "default": null,
               "format": "date-time",
               "title": "Lastchangeddate",
               "type": "string"
            },
            "LastAccessedDate": {
               "default": null,
               "format": "date-time",
               "title": "Lastaccesseddate",
               "type": "string"
            },
            "DeletedDate": {
               "default": null,
               "format": "date-time",
               "title": "Deleteddate",
               "type": "string"
            },
            "NextRotationDate": {
               "default": null,
               "format": "date-time",
               "title": "Nextrotationdate",
               "type": "string"
            },
            "Tags": {
               "anyOf": [
                  {
                     "items": {
                        "$ref": "#/$defs/Tag"
                     },
                     "type": "array"
                  },
                  {
                     "type": "null"
                  }
               ],
               "title": "Tags"
            },
            "SecretVersionsToStages": {
               "additionalProperties": {
                  "items": {
                     "type": "string"
                  },
                  "type": "array"
               },
               "title": "Secretversionstostages",
               "type": "object"
            },
            "OwningService": {
               "default": null,
               "title": "Owningservice",
               "type": "string"
            },
            "CreatedDate": {
               "default": null,
               "format": "date-time",
               "title": "Createddate",
               "type": "string"
            },
            "PrimaryRegion": {
               "default": null,
               "title": "Primaryregion",
               "type": "string"
            }
         },
         "required": [
            "Name"
         ],
         "title": "Secret",
         "type": "object"
      },
      "Tag": {
         "description": "The metadata that you apply to a resource to help you categorize and\norganize them. Each tag consists of a key and an optional value. You define\nthem.\n\nThe following basic restrictions apply to tags:\n\n* Maximum number of tags per resource - 50\n* For each resource, each tag key must be unique, and each tag key can have\n  only one value.\n* Maximum key length - 128 Unicode characters in UTF-8\n* Maximum value length - 256 Unicode characters in UTF-8\n* If your tagging schema is used across multiple services and resources,\n  remember that other services may have restrictions on allowed characters.\n  Generally allowed characters are: letters, numbers, and spaces representable in\n  UTF-8, and the following characters: + - = . _ : / @.\n* Tag keys and values are case-sensitive.\n* Do not use ``aws:``, ``AWS:``, or any upper or lowercase combination of such\n  as a prefix for either keys or values as it is reserved for Amazon Web Services\n  use. You cannot edit or delete tag keys or values with this prefix. Tags with\n  this prefix do not count against your tags per resource limit.",
         "properties": {
            "session": {
               "anyOf": [
                  {},
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Session"
            },
            "Key": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Key"
            },
            "Value": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Value"
            }
         },
         "title": "Tag",
         "type": "object"
      }
   }
}

Config:

validate_assignment: bool = True
arbitrary_types_allowed: bool = True

Fields:

NextToken (str | None)
SecretList (list[botocraft.services.secretsmanager.Secret] | None)
session (Any | None)

field NextToken: str | None = None

Secrets Manager includes this value if there’s more output available than what is included in the current response.

This can occur even when the response includes no values at all, such as when you ask for a filtered view of a long list. To get the next results, call ListSecrets again with this value.

field SecretList: builtins.list[Secret] | None [Optional]: A list of the secrets in the account.

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.secretsmanager.PutResourcePolicyResponse[source]

Bases: Boto3Model

Show JSON schema

{
   "title": "PutResourcePolicyResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "ARN": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Arn"
      },
      "Name": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Name"
      }
   }
}

Config:

validate_assignment: bool = True
arbitrary_types_allowed: bool = True

Fields:

ARN (str | None)
Name (str | None)
session (Any | None)

field ARN: str | None = None: The ARN of the secret.

field Name: str | None = None: The name of the secret.

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.secretsmanager.PutSecretValueResponse[source]

Bases: Boto3Model

Show JSON schema

{
   "title": "PutSecretValueResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "ARN": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Arn"
      },
      "Name": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Name"
      },
      "VersionId": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Versionid"
      },
      "VersionStages": {
         "anyOf": [
            {
               "items": {
                  "type": "string"
               },
               "type": "array"
            },
            {
               "type": "null"
            }
         ],
         "title": "Versionstages"
      }
   }
}

Config:

validate_assignment: bool = True
arbitrary_types_allowed: bool = True

Fields:

ARN (str | None)
Name (str | None)
VersionId (str | None)
VersionStages (list[str] | None)
session (Any | None)

field ARN: str | None = None: The ARN of the secret.

field Name: str | None = None: The name of the secret.

field VersionId: str | None = None: The unique identifier of the version of the secret.

field VersionStages: builtins.list[str] | None [Optional]

The list of staging labels that are currently attached to this version of the secret.

Secrets Manager uses staging labels to track a version as it progresses through the secret rotation process.

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.secretsmanager.ReplicaRegionType[source]

Bases: Boto3Model

A custom type that specifies a Region and the KmsKeyId for a replica secret.

Show JSON schema

{
   "title": "ReplicaRegionType",
   "description": "A custom type that specifies a ``Region`` and the ``KmsKeyId`` for a replica secret.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "Region": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Region"
      },
      "KmsKeyId": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Kmskeyid"
      }
   }
}

Config:

validate_assignment: bool = True
arbitrary_types_allowed: bool = True

Fields:

KmsKeyId (str | None)
Region (str | None)
session (Any | None)

field KmsKeyId: str | None = None

The ARN, key ID, or alias of the KMS key to encrypt the secret.

If you don’t include this field, Secrets Manager uses aws/secretsmanager.

field Region: str | None = None

A Region code.

For a list of Region codes, see Name and code of Regions.

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.secretsmanager.ReplicationStatusType[source]

Bases: Boto3Model

A replication object consisting of a RegionReplicationStatus object and includes a Region, KMSKeyId, status, and status message.

Show JSON schema

{
   "title": "ReplicationStatusType",
   "description": "A replication object consisting of a ``RegionReplicationStatus`` object and includes\na Region, KMSKeyId, status, and status message.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "Region": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Region"
      },
      "KmsKeyId": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Kmskeyid"
      },
      "Status": {
         "anyOf": [
            {
               "enum": [
                  "InSync",
                  "Failed",
                  "InProgress"
               ],
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Status"
      },
      "StatusMessage": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Statusmessage"
      },
      "LastAccessedDate": {
         "anyOf": [
            {
               "format": "date-time",
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Lastaccesseddate"
      }
   }
}

Config:

validate_assignment: bool = True
arbitrary_types_allowed: bool = True

Fields:

KmsKeyId (str | None)
LastAccessedDate (datetime.datetime | None)
Region (str | None)
Status (Literal['InSync', 'Failed', 'InProgress'] | None)
StatusMessage (str | None)
session (Any | None)

field KmsKeyId: str | None = None: Can be an ARN, Key ID, or Alias.

field LastAccessedDate: datetime | None = None

The date that the secret was last accessed in the Region.

This field is omitted if the secret has never been retrieved in the Region.

field Region: str | None = None: The Region where replication occurs.

field Status: Literal['InSync', 'Failed', 'InProgress'] | None = None: The status can be InProgress, Failed, or InSync.

field StatusMessage: str | None = None: Status message such as “Secret with this name already exists in this region”.

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.secretsmanager.RestoreSecretResponse[source]

Bases: Boto3Model

Show JSON schema

{
   "title": "RestoreSecretResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "ARN": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Arn"
      },
      "Name": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Name"
      }
   }
}

Config:

validate_assignment: bool = True
arbitrary_types_allowed: bool = True

Fields:

ARN (str | None)
Name (str | None)
session (Any | None)

field ARN: str | None = None: The ARN of the secret that was restored.

field Name: str | None = None: The name of the secret that was restored.

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.secretsmanager.RotateSecretResponse[source]

Bases: Boto3Model

Show JSON schema

{
   "title": "RotateSecretResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "ARN": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Arn"
      },
      "Name": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Name"
      },
      "VersionId": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Versionid"
      }
   }
}

Config:

validate_assignment: bool = True
arbitrary_types_allowed: bool = True

Fields:

ARN (str | None)
Name (str | None)
VersionId (str | None)
session (Any | None)

field ARN: str | None = None: The ARN of the secret.

field Name: str | None = None: The name of the secret.

field VersionId: str | None = None: The ID of the new version of the secret.

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.secretsmanager.SecretsFilter[source]

Bases: Boto3Model

Allows you to add filters when you use the search function in Secrets Manager.

For more information, see Find secrets in Secrets Manager.

Show JSON schema

{
   "title": "SecretsFilter",
   "description": "Allows you to add filters when you use the search function in Secrets Manager.\n\nFor more information, see\n`Find secrets in Secrets Manager <https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_search-secret.html>`_.",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "Key": {
         "enum": [
            "description",
            "name",
            "tag-key",
            "tag-value",
            "primary-region",
            "owning-service",
            "all"
         ],
         "title": "Key",
         "type": "string"
      },
      "Values": {
         "items": {
            "type": "string"
         },
         "title": "Values",
         "type": "array"
      }
   },
   "required": [
      "Key",
      "Values"
   ]
}

Config:

validate_assignment: bool = True
arbitrary_types_allowed: bool = True

Fields:

Key (Literal['description', 'name', 'tag-key', 'tag-value', 'primary-region', 'owning-service', 'all'])
Values (list[str])
session (Any | None)

field Key: Literal['description', 'name', 'tag-key', 'tag-value', 'primary-region', 'owning-service', 'all'] [Required]: The following are keys you can use:

field Values: builtins.list[str] [Required]: The keyword to filter for.

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.secretsmanager.UpdateSecretResponse[source]

Bases: Boto3Model

Show JSON schema

{
   "title": "UpdateSecretResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "ARN": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Arn"
      },
      "Name": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Name"
      },
      "VersionId": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Versionid"
      }
   }
}

Config:

validate_assignment: bool = True
arbitrary_types_allowed: bool = True

Fields:

ARN (str | None)
Name (str | None)
VersionId (str | None)
session (Any | None)

field ARN: str | None = None: The ARN of the secret that was updated.

field Name: str | None = None: The name of the secret that was updated.

field VersionId: str | None = None: If Secrets Manager created a new version of the secret during this operation, then VersionId contains the unique identifier of the new version.

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.secretsmanager.UpdateSecretVersionStageResponse[source]

Bases: Boto3Model

Show JSON schema

{
   "title": "UpdateSecretVersionStageResponse",
   "type": "object",
   "properties": {
      "session": {
         "anyOf": [
            {},
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Session"
      },
      "ARN": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Arn"
      },
      "Name": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Name"
      }
   }
}

Config:

validate_assignment: bool = True
arbitrary_types_allowed: bool = True

Fields:

ARN (str | None)
Name (str | None)
session (Any | None)

field ARN: str | None = None: The ARN of the secret that was updated.

field Name: str | None = None: The name of the secret that was updated.

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.