air_sdk.endpoints.manifests | DSX Air Documentation

Stub file for manifests endpoint type hints.

Classes

Name	Description
`Manifest`	Manifest model representing a simulator/platform configuration.
`ManifestEndpointAPI`	API client for manifest endpoints.

Module Contents

class air_sdk.endpoints.manifests.Manifest

Bases: air_sdk.bc.BaseCompatMixin, air_sdk.bc.manifests.ManifestCompatMixin, air_sdk.air_model.AirModel

Manifest model representing a simulator/platform configuration.

Manifests define how a specific network device or platform should be emulated, including resource requirements, docker parameters, and platform capabilities.

id: str

Unique identifier for the manifest (required)

org_name: str

Organization name that owns this manifest (read-only, set by API)

docker_run_parameters: dict[str, Any]

Docker container runtime parameters (required)

emulation_type: str

Type of emulation (required)

platform_information: dict[str, Any]

Dictionary of platform configurations (required)

simulator_image: Image

Docker image used for the simulator (required)

simulator_resources: dict[str, Any]

Resource requirements for the simulator (required)

description: str | None

Manifest description (optional)

artifacts_directory: str | None

Directory path for simulator artifacts (optional)

artifacts_directory_max_size_gb: int | None

Maximum size for artifacts dir in GB (optional)

boot_group: int | None

Boot group number for startup ordering (optional)

configure_node_properties: dict[str, Any] | None

Node configuration properties (optional)

configure_simulator: dict[str, Any] | None

Simulator configuration parameters (optional)

simulation_engine_versions: list[str] | None

List of supported sim engine versions (optional)

emulation_params: dict[str, Any] | None

Emulation-specific parameters (optional)

port_mapping_required: bool | None

Whether port mapping is required (optional, read-only)

get_model_api() -> type[ManifestEndpointAPI]

Returns the respective AirModelAPI type for this model.

Returns:

ManifestEndpointAPI class

model_api: ManifestEndpointAPI

The current model API instance.

Returns:

ManifestEndpointAPI instance

update(
    *,
    docker_run_parameters: DockerRunParameters | dict[str, Any] = ...,
    emulation_type: str = ...,
    platform_information: dict[str, Platform | dict[str, Any]] = ...,
    simulator_image: Image | str = ...,
    simulator_resources: Resources | dict[str, Any] = ...,
    description: str = ...,
    artifacts_directory: str = ...,
    artifacts_directory_max_size_gb: int = ...,
    boot_group: int = ...,
    configure_node_properties: dict[str, Any] = ...,
    configure_simulator: dict[str, Any] = ...,
    simulation_engine_versions: list[str] = ...,
    emulation_params: EmulationParams | dict[str, Any] = ...
) -> None

Update the manifest’s properties.

Parameters:

docker_run_parameters – Docker runtime parameters
emulation_type – Type of emulation
platform_information – Platform configurations
simulator_image – Docker image for the simulator
simulator_resources – Resource requirements
description – Manifest description
artifacts_directory – Directory path for simulator artifacts
artifacts_directory_max_size_gb – Max size for artifacts dir
boot_group – Boot group number
configure_node_properties – Node configuration properties
configure_simulator – Simulator configuration
simulation_engine_versions – Supported engine versions
emulation_params – Emulation parameters

Example:

>>> manifest.update(boot_group=2)
>>> manifest.update(description='Updated manifest')

delete() -> None

Delete this manifest.

Example:

>>> manifest = api.manifests.get('manifest-id-123')
>>> manifest.delete()

class air_sdk.endpoints.manifests.ManifestEndpointAPI

Bases: air_sdk.air_model.BaseEndpointAPI[air_sdk.endpoints.manifests.Manifest]

API client for manifest endpoints.

API_PATH: str

model: type[Manifest]

list(
    *,
    id: str = ...,
    org_name: str = ...,
    emulation_type: str = ...,
    port_mapping_required: bool = ...,
    limit: int = ...,
    offset: int = ...,
    ordering: str = ...,
    search: str = ...,
    **params: Any
) -> Iterator[Manifest]

List all manifests with optional filtering.

Parameters:

id – Filter by manifest ID
org_name – Filter by organization name
emulation_type – Filter by emulation type
port_mapping_required – Filter by port mapping requirement (V2 BC field)
limit – Number of results to return per page
offset – The initial index from which to return the results
ordering – Order objects by field. Prefix with ”-” for desc order
search – Search term to filter manifests
**params – Additional query parameters

Returns:

Iterator of Manifest instances

Example:

>>> # List all manifests
>>> for manifest in api.manifests.list():
...     print(manifest.emulation_type)
>>> # Filter by emulation type
>>> for manifest in api.manifests.list(emulation_type='NIC_INFINIBAND'):
    ...     print(manifest.org_name)
>>> # Search and order
>>> for manifest in api.manifests.list(search='cumulus', ordering='-created'):
...     print(manifest.id)

create(
    *,
    docker_run_parameters: DockerRunParameters | dict[str, Any],
    emulation_type: str,
    platform_information: dict[str, Platform | dict[str, Any]],
    simulator_image: Image | str,
    simulator_resources: Resources | dict[str, Any],
    description: str = ...,
    artifacts_directory: str = ...,
    artifacts_directory_max_size_gb: int = ...,
    boot_group: int = ...,
    configure_node_properties: dict[str, Any] = ...,
    configure_simulator: dict[str, Any] = ...,
    simulation_engine_versions: List[str] = ...,
    emulation_params: EmulationParams | dict[str, Any] = ...,
    **kwargs: Any
) -> Manifest

Create a new manifest.

Note: org_name is automatically determined by API and cannot be specified.

Parameters:

docker_run_parameters – Docker runtime parameters (required)
emulation_type – Type of emulation (required)
platform_information – Platform configurations (required)
simulator_image – Docker image for the simulator - Image obj or ID (required)
simulator_resources – Resource requirements (required)
description – Manifest description (optional)
artifacts_directory – Directory path for simulator artifacts (optional)
artifacts_directory_max_size_gb – Max size for artifacts dir (optional)
boot_group – Boot group number (optional)
configure_node_properties – Node configuration properties (optional)
configure_simulator – Simulator configuration (optional)
simulation_engine_versions – Supported engine versions (optional)
emulation_params – Emulation parameters (optional)
**kwargs – Additional fields

Returns:

The created Manifest instance

Example:

>>> manifest = api.manifests.create(
...     artifacts_directory='/artifacts',
...     artifacts_directory_max_size_gb=10,
...     boot_group=1,
...     configure_node_properties={},
...     configure_simulator={},
...     docker_run_parameters={
...         'tmpfs': [],
...         'cap_add': ['NET_ADMIN'],
...         'devices': ['/dev/kvm'],
...         'volumes': [],
...         'environment': {},
...     },
...     emulation_type='NIC_INFINIBAND',
...     platform_information={},
...     simulation_engine_versions=['1.0'],
...     simulator_image='image-id',
...     simulator_resources={'cpu': 2.0, 'memory': 4096},
...     emulation_params={
...         'direct_link_emulation': True,
...         'max_network_pci': 8,
...     },
... )

get(pk: PrimaryKey) -> Manifest

Get a specific manifest by ID.

Parameters:

pk – The manifest ID (string or UUID)

Returns:

The Manifest instance

Example:

>>> manifest = api.manifests.get('manifest-id-123')
>>> print(manifest.emulation_type)

patch(
    pk: PrimaryKey,
    *,
    docker_run_parameters: DockerRunParameters | dict[str, Any] = ...,
    emulation_type: str = ...,
    platform_information: dict[str, Platform | dict[str, Any]] = ...,
    simulator_image: Image | str = ...,
    simulator_resources: Resources | dict[str, Any] = ...,
    description: str = ...,
    artifacts_directory: str = ...,
    artifacts_directory_max_size_gb: int = ...,
    boot_group: int = ...,
    configure_node_properties: dict[str, Any] = ...,
    configure_simulator: dict[str, Any] = ...,
    simulation_engine_versions: List[str] = ...,
    emulation_params: EmulationParams | dict[str, Any] = ...,
    **kwargs: Any
) -> Manifest

Update a manifest’s properties.

Parameters:

pk – The manifest ID (string or UUID)
docker_run_parameters – Docker runtime parameters
emulation_type – Type of emulation
platform_information – Platform configurations
simulator_image – Docker image for the simulator
simulator_resources – Resource requirements
description – Manifest description
artifacts_directory – Directory path for simulator artifacts
artifacts_directory_max_size_gb – Max size for artifacts dir
boot_group – Boot group number
configure_node_properties – Node configuration properties
configure_simulator – Simulator configuration
simulation_engine_versions – Supported engine versions
emulation_params – Emulation parameters
**kwargs – Additional fields to update

Returns:

The updated Manifest instance

Example:

>>> updated_manifest = api.manifests.patch(
...     pk='manifest-id-123',
...     boot_group=2,
... )

delete(
    pk: PrimaryKey,
    **kwargs: Any
) -> None

Delete a manifest.

Parameters:

pk – The manifest ID (string or UUID) to delete
**kwargs – Additional parameters

Example:

>>> api.manifests.delete('manifest-id-123')