`antimatter.session_mixins.identity_provider_mixin`#

Module Contents#

Classes#

`OverrideDomainIdentityPrincipalDetails`	This override provides a local way to pass domain identity principal details
`IdentityProviderMixin`	Session mixin defining identity provider CRUD functionality.

class antimatter.session_mixins.identity_provider_mixin.OverrideDomainIdentityPrincipalDetails(*args, **kwargs)#

Bases: antimatter.client.DomainIdentityPrincipalDetails

This override provides a local way to pass domain identity principal details to the openapi generated client that mitigates the pydantic serializing error it produces due to a bug in the generator.

The code that the generator currently produces looks like: ` one_of_schemas: List[str] = Literal["APIKeyDomainIdentityProviderDetails", "GoogleOAuthDomainIdentityProviderDetails"] ` that will produce the error: ` /Users/daniel/.pyenv/versions/pycapsule-3.11/lib/python3.11/site-packages/pydantic/main.py:308: UserWarning: Pydantic serializer warnings: Expected `list[str]` but got `_LiteralGenericAlias` - serialized value may not be as expected return self.__pydantic_serializer__.to_python( `

property model_extra: dict[str, Any] | None#

Get extra fields set during validation.

Returns:: A dictionary of extra fields, or None if config.extra is not set to “allow”.

property model_fields_set: set[str]#

Returns the set of fields that have been explicitly set on this model instance.

Returns:

A set of strings representing the fields that have been set,: i.e. that were not filled from defaults.

one_of_schemas: List[str] = ['DomainIdentityAPIKeyPrincipalParams', 'DomainIdentityEmailPrincipalParams',...#

oneof_schema_1_validator: antimatter.client.models.domain_identity_api_key_principal_params.DomainIdentityAPIKeyPrincipalParams | None#

oneof_schema_2_validator: antimatter.client.models.domain_identity_email_principal_params.DomainIdentityEmailPrincipalParams | None#

oneof_schema_3_validator: antimatter.client.models.domain_identity_hosted_domain_principal_params.DomainIdentityHostedDomainPrincipalParams | None#

actual_instance: antimatter.client.models.domain_identity_api_key_principal_params.DomainIdentityAPIKeyPrincipalParams | antimatter.client.models.domain_identity_email_principal_params.DomainIdentityEmailPrincipalParams | antimatter.client.models.domain_identity_hosted_domain_principal_params.DomainIdentityHostedDomainPrincipalParams | None#

model_config#

discriminator_value_class_map: Dict[str, str]#

actual_instance_must_validate_oneof(v)#

classmethod from_dict(obj: dict) → Self#

classmethod from_json(json_str: str) → Self#: Returns the object represented by the json string

to_json() → str#: Returns the JSON representation of the actual instance

to_dict() → Dict#: Returns the dict representation of the actual instance

to_str() → str#: Returns the string representation of the actual instance

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

Creates a new instance of the Model class with validated data.

Creates a new model setting __dict__ and __pydantic_fields_set__ from trusted or pre-validated data. Default values are respected, but no other validation is performed. Behaves as if Config.extra = ‘allow’ was set since it adds all passed values

Args:: _fields_set: The set of field names accepted for the Model instance. values: Trusted or pre-validated data dictionary.
Returns:: A new instance of the Model class with validated data.

model_copy(*, update: dict[str, Any] | None = None, deep: bool = False) → Model#

Usage docs: https://docs.pydantic.dev/2.6/concepts/serialization/#model_copy

Returns a copy of the model.

Args:

update: Values to change/add in the new model. Note: the data is not validated: before creating the new model. You should trust this data.

deep: Set to True to make a deep copy of the model.

Returns:

New model instance.

model_dump(*, mode: typing_extensions.Literal[json, python] | str = 'python', include: IncEx = None, exclude: IncEx = None, by_alias: bool = False, exclude_unset: bool = False, exclude_defaults: bool = False, exclude_none: bool = False, round_trip: bool = False, warnings: bool = True) → dict[str, Any]#

Usage docs: https://docs.pydantic.dev/2.6/concepts/serialization/#modelmodel_dump

Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.

Args:

mode: The mode in which to_python should run.: If mode is ‘json’, the output will only contain JSON serializable types. If mode is ‘python’, the output may contain non-JSON-serializable Python objects.

include: A list of fields to include in the output. exclude: A list of fields to exclude from the output. by_alias: Whether to use the field’s alias in the dictionary key if defined. exclude_unset: Whether to exclude fields that have not been explicitly set. exclude_defaults: Whether to exclude fields that are set to their default value. exclude_none: Whether to exclude fields that have a value of None. round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T]. warnings: Whether to log warnings when invalid fields are encountered.

Returns:

A dictionary representation of the model.

model_dump_json(*, indent: int | None = None, include: IncEx = None, exclude: IncEx = None, by_alias: bool = False, exclude_unset: bool = False, exclude_defaults: bool = False, exclude_none: bool = False, round_trip: bool = False, warnings: bool = True) → str#

Usage docs: https://docs.pydantic.dev/2.6/concepts/serialization/#modelmodel_dump_json

Generates a JSON representation of the model using Pydantic’s to_json method.

Args:: indent: Indentation to use in the JSON output. If None is passed, the output will be compact. include: Field(s) to include in the JSON output. exclude: Field(s) to exclude from the JSON output. by_alias: Whether to serialize using field aliases. exclude_unset: Whether to exclude fields that have not been explicitly set. exclude_defaults: Whether to exclude fields that are set to their default value. exclude_none: Whether to exclude fields that have a value of None. round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T]. warnings: Whether to log warnings when invalid fields are encountered.
Returns:: A JSON string representation of the model.

classmethod model_json_schema(by_alias: bool = True, ref_template: str = DEFAULT_REF_TEMPLATE, schema_generator: type[pydantic.json_schema.GenerateJsonSchema] = GenerateJsonSchema, mode: pydantic.json_schema.JsonSchemaMode = 'validation') → dict[str, Any]#

Generates a JSON schema for a model class.

Args:

by_alias: Whether to use attribute aliases or not. ref_template: The reference template. schema_generator: To override the logic used to generate the JSON schema, as a subclass of

GenerateJsonSchema with your desired modifications

mode: The mode in which to generate the schema.

Returns:

The JSON schema for the given model class.

classmethod model_parametrized_name(params: tuple[type[Any], Ellipsis]) → str#

Compute the class name for parametrizations of generic classes.

This method can be overridden to achieve a custom naming scheme for generic BaseModels.

Args:

params: Tuple of types of the class. Given a generic class: Model with 2 type variables and a concrete model Model[str, int], the value (str, int) would be passed to params.

Returns:

String representing the new class where params are passed to cls as type variables.

Raises:

TypeError: Raised when trying to generate concrete names for non-generic models.

model_post_init(__context: Any) → None#: Override this method to perform additional initialization after __init__ and model_construct. This is useful if you want to do some validation that requires the entire model to be initialized.

classmethod model_rebuild(*, force: bool = False, raise_errors: bool = True, _parent_namespace_depth: int = 2, _types_namespace: dict[str, Any] | None = None) → bool | None#

Try to rebuild the pydantic-core schema for the model.

This may be necessary when one of the annotations is a ForwardRef which could not be resolved during the initial attempt to build the schema, and automatic rebuilding fails.

Args:: force: Whether to force the rebuilding of the model schema, defaults to False. raise_errors: Whether to raise errors, defaults to True. _parent_namespace_depth: The depth level of the parent namespace, defaults to 2. _types_namespace: The types namespace, defaults to None.
Returns:: Returns None if the schema is already “complete” and rebuilding was not required. If rebuilding _was_ required, returns True if rebuilding was successful, otherwise False.

classmethod model_validate(obj: Any, *, strict: bool | None = None, from_attributes: bool | None = None, context: dict[str, Any] | None = None) → Model#

Validate a pydantic model instance.

Args:: obj: The object to validate. strict: Whether to enforce types strictly. from_attributes: Whether to extract data from object attributes. context: Additional context to pass to the validator.
Raises:: ValidationError: If the object could not be validated.
Returns:: The validated model instance.

classmethod model_validate_json(json_data: str | bytes | bytearray, *, strict: bool | None = None, context: dict[str, Any] | None = None) → Model#

Usage docs: https://docs.pydantic.dev/2.6/concepts/json/#json-parsing

Validate the given JSON data against the Pydantic model.

Args:: json_data: The JSON data to validate. strict: Whether to enforce types strictly. context: Extra variables to pass to the validator.
Returns:: The validated Pydantic model.
Raises:: ValueError: If json_data is not a JSON string.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: dict[str, Any] | None = None) → Model#

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

Args:: obj: The object contains string data to validate. strict: Whether to enforce types strictly. context: Extra variables to pass to the validator.
Returns:: The validated Pydantic model.

dict(*, include: IncEx = None, exclude: IncEx = None, by_alias: bool = False, exclude_unset: bool = False, exclude_defaults: bool = False, exclude_none: bool = False) → Dict[str, Any]#

json(*, include: IncEx = None, exclude: IncEx = None, by_alias: bool = False, exclude_unset: bool = False, exclude_defaults: bool = False, exclude_none: bool = False, encoder: Callable[[Any], Any] | None = PydanticUndefined, models_as_dict: bool = PydanticUndefined, **dumps_kwargs: Any) → str#

classmethod parse_obj(obj: Any) → Model#

classmethod parse_raw(b: str | bytes, *, content_type: str | None = None, encoding: str = 'utf8', proto: pydantic.deprecated.parse.Protocol | None = None, allow_pickle: bool = False) → Model#

classmethod parse_file(path: str | pathlib.Path, *, content_type: str | None = None, encoding: str = 'utf8', proto: pydantic.deprecated.parse.Protocol | None = None, allow_pickle: bool = False) → Model#

classmethod from_orm(obj: Any) → Model#

classmethod construct(_fields_set: set[str] | None = None, **values: Any) → Model#

copy(*, include: pydantic._internal._utils.AbstractSetIntStr | pydantic._internal._utils.MappingIntStrAny | None = None, exclude: pydantic._internal._utils.AbstractSetIntStr | pydantic._internal._utils.MappingIntStrAny | None = None, update: Dict[str, Any] | None = None, deep: bool = False) → Model#

Returns a copy of the model.

!!! warning “Deprecated”: This method is now deprecated; use model_copy instead.

If you need include or exclude, use:

`py data = self.model_dump(include=include, exclude=exclude, round_trip=True) data = {**data, **(update or {})} copied = self.model_validate(data) `

Args:: include: Optional set or mapping specifying which fields to include in the copied model. exclude: Optional set or mapping specifying which fields to exclude in the copied model. update: Optional dictionary of field-value pairs to override field values in the copied model. deep: If True, the values of fields that are Pydantic models will be deep-copied.
Returns:: A copy of the model with included, excluded and updated fields as specified.

classmethod schema(by_alias: bool = True, ref_template: str = DEFAULT_REF_TEMPLATE) → Dict[str, Any]#

classmethod schema_json(*, by_alias: bool = True, ref_template: str = DEFAULT_REF_TEMPLATE, **dumps_kwargs: Any) → str#

classmethod validate(value: Any) → Model#

classmethod update_forward_refs(**localns: Any) → None#

class antimatter.session_mixins.identity_provider_mixin.IdentityProviderMixin(domain: str, client_func: Callable[[], antimatter.client.DefaultApi], **kwargs)#

Session mixin defining identity provider CRUD functionality.

Parameters:

domain – The domain to use for the session.
client – The client to use for the session.

upsert_identity_provider(provider_name: str, provider_type: str | antimatter.constants.identity_provider.ProviderType = ProviderType.ApiKey, client_id: str | None = None) → Dict[str, Any]#

Create or update an identity provider.

Parameters:

provider_name – The name of a new or existing identity provider
provider_type – The provider type for identity management
client_id – If the provider type is ‘GoogleOAuth’, a client ID must be provided

Returns:

The identity provider summary

insert_identity_provider_principal(provider_name: str, capabilities: Dict[str, str], principal_type: str | antimatter.constants.identity_provider.PrincipalType, principal_value: str | None = None) → Dict[str, str]#

Creates a new principal for the provider. Note that the provider_name must refer to an existing identity provider. The principal_value is optional if the type is APIKey.

Parameters:

provider_name – The name of an existing identity provider
capabilities – The capabilities to attach to the principal
principal_type – The type of principal to create. One of ‘APIKey’, ‘Email’, or ‘HostedDomain’
principal_value – The appropriate identifying value for the principal, depending on type

Returns:

The ID of the inserted principal and any additional metadata

update_identity_provider_principal(provider_name: str, principal_id: str, capabilities: Dict[str, str]) → None#

Update the capabilities for an identity provider principal.

Parameters:

provider_name – The name of an existing identity provider
principal_id – The ID of the principal
capabilities – The capabilities to attach to the principal

get_identity_provider(provider_name: str) → Dict[str, Any]#

Retrieve detailed information and configuration of an identity provider

Parameters:: provider_name – The name of an existing identity provider
Returns:: The identity provider details

list_identity_providers() → List[Dict[str, Any]]#: Retrieve the domain’s identity providers and a brief overview of their configuration.

get_identity_provider_principal(provider_name: str, principal_id: str | None = None) → List[Dict[str, Any]] | Dict[str, Any]#

Get either a summary of all the principals for an identity provider, or detailed information about a single principal if a principal_id is provided

Parameters:

provider_name – The name of an existing identity provider
principal_id – The ID of the principal; None to get all principals

Returns:

The principal information

delete_identity_provider(provider_name: str) → None#

Delete an identity provider. All domain tokens created using this identity provider will be invalidated. Take care not to remove the identity provider that is providing you admin access to your domain, as you may lock yourself out.

Parameters:: provider_name – The name of the identity provider to fully delete

delete_identity_provider_principal(provider_name: str, principal_id: str) → None#

Delete an identity provider principal.

Parameters:

provider_name – The name of the identity provider to delete a principal from
principal_id – The ID of the principal to delete

antimatter.session_mixins.identity_provider_mixin#

Module Contents#

Classes#

`antimatter.session_mixins.identity_provider_mixin`#