async def allocate(
            cls, *,
            hostname: str = None,
            architectures: typing.Sequence[str] = None,
            cpus: int = None,
            fabrics: typing.Sequence[FabricParam] = None,
            interfaces: typing.Sequence[InterfaceParam] = None,
            memory: float = None,
            pod: typing.Union[str, Pod] = None,
            not_pod: typing.Union[str, Pod] = None,
            pod_type: str = None,
            not_pod_type: str = None,
            storage: typing.Sequence[str] = None,
            subnets: typing.Sequence[SubnetParam] = None,
            tags: typing.Sequence[str] = None,
            zone: typing.Union[str, Zone] = None,
            not_fabrics: typing.Sequence[FabricParam] = None,
            not_subnets: typing.Sequence[SubnetParam] = None,
            not_tags: typing.Sequence[str] = None,
            not_zones: typing.Sequence[ZoneParam] = None,
            agent_name: str = None, comment: str = None,
            bridge_all: bool = None, bridge_stp: bool = None,
            bridge_fd: int = None, dry_run: bool = None, verbose: bool = None):
        """
        Allocate a machine.

        :param hostname: The hostname to match.
        :type hostname: `str`
        :param architectures: The architecture(s) to match.
        :type architectures: sequence of `str`
        :param cpus: The minimum number of CPUs to match.
        :type cpus: `int`
        :param fabrics: The connected fabrics to match.
        :type fabrics: sequence of either `str`, `int`, or `Fabric`
        :param interfaces: The interfaces to match.
        :type interfaces: sequence of either `str`, `int`, or `Interface`
        :param memory: The minimum amount of RAM to match in MiB.
        :type memory: `int`
        :param pod: The pod to allocate the machine from.
        :type pod: `str`
        :param not_pod: Pod the machine must not be located in.
        :type not_pod: `str`
        :param pod_type: The type of pod to allocate the machine from.
        :type pod_type: `str`
        :param not_pod_type: Pod type the machine must not be located in.
        :type not_pod_type: `str`
        :param subnets: The subnet(s) the desired machine must be linked to.
        :type subnets: sequence of `str` or `int` or `Subnet`
        :param storage: The storage contraint to match.
        :type storage: `str`
        :param tags: The tags to match, as a sequence.
        :type tags: sequence of `str`
        :param zone: The zone the desired machine must belong to.
        :type zone: `str` or `Zone`
        :param not_fabrics: The fabrics the machine must NOT be connected to.
        :type not_fabrics: sequence of either `str`, `int`, or `Fabric`
        :param not_subnets: The subnet(s) the desired machine must NOT be
            linked to.
        :type not_subnets: sequence of `str` or `int` or `Subnet`
        :param not_zones: The zone(s) the desired machine must NOT in.
        :type not_zones: sequence of `str` or `Zone`
        :param agent_name: Agent name to attach to the acquire machine.
        :type agent_name: `str`
        :param comment: Comment for the allocate event placed on machine.
        :type comment: `str`
        :param bridge_all: Automatically create a bridge on all interfaces
            on the allocated machine.
        :type bridge_all: `bool`
        :param bridge_stp: Turn spaning tree protocol on or off for the
            bridges created with bridge_all.
        :type bridge_stp: `bool`
        :param bridge_fd: Set the forward delay in seconds on the bridges
            created with bridge_all.
        :type bridge_fd: `int`
        :param dry_run: Don't actually acquire the machine just return the
            machine that would have been acquired.
        :type dry_run: `bool`
        :param verbose: Indicate that the user would like additional verbosity
            in the constraints_by_type field (each constraint will be prefixed
            by `verbose_`, and contain the full data structure that indicates
            which machine(s) matched).
        :type verbose: `bool`
        """
        params = remove_None({
            'name': hostname,
            'arch': architectures,
            'cpu_count': str(cpus) if cpus else None,
            'mem': str(memory) if memory else None,
            'pod_type': pod_type,
            'not_pod_type': not_pod_type,
            'storage': storage,
            'tags': tags,
            'not_tags': not_tags,
            'agent_name': agent_name,
            'comment': comment,
            'bridge_all': bridge_all,
            'bridge_stp': bridge_stp,
            'bridge_fd': bridge_fd,
            'dry_run': dry_run,
            'verbose': verbose,
        })
        if fabrics is not None:
            params["fabrics"] = [
                get_param_arg('fabrics', idx, Fabric, fabric)
                for idx, fabric in enumerate(fabrics)
            ]
        if interfaces is not None:
            params["interfaces"] = [
                get_param_arg('interfaces', idx, Interface, nic)
                for idx, nic in enumerate(interfaces)
            ]
        if pod is not None:
            if isinstance(pod, Pod):
                params["pod"] = pod.name
            elif isinstance(pod, str):
                params["pod"] = pod
            else:
                raise TypeError(
                    "pod must be a str or Pod, not %s" % type(pod).__name__)
        if not_pod is not None:
            if isinstance(not_pod, Pod):
                params["not_pod"] = not_pod.name
            elif isinstance(not_pod, str):
                params["not_pod"] = not_pod
            else:
                raise TypeError(
                    "not_pod must be a str or Pod, not %s" %
                    type(not_pod).__name__)
        if subnets is not None:
            params["subnets"] = [
                get_param_arg('subnets', idx, Subnet, subnet)
                for idx, subnet in enumerate(subnets)
            ]
        if zone is not None:
            if isinstance(zone, Zone):
                params["zone"] = zone.name
            elif isinstance(zone, str):
                params["zone"] = zone
            else:
                raise TypeError(
                    "zone must be a str or Zone, not %s" % type(zone).__name__)
        if not_fabrics is not None:
            params["not_fabrics"] = [
                get_param_arg('not_fabrics', idx, Fabric, fabric)
                for idx, fabric in enumerate(not_fabrics)
            ]
        if not_subnets is not None:
            params["not_subnets"] = [
                get_param_arg('not_subnets', idx, Subnet, subnet)
                for idx, subnet in enumerate(not_subnets)
            ]
        if not_zones is not None:
            params["not_in_zones"] = [
                get_param_arg('not_zones', idx, Zone, zone, attr='name')
                for idx, zone in enumerate(not_zones)
            ]
        try:
            data = await cls._handler.allocate(**params)
        except CallError as error:
            if error.status == HTTPStatus.CONFLICT:
                message = "No machine matching the given criteria was found."
                raise MachineNotFound(message) from error
            else:
                raise
        else:
            return cls._object(data)
Allocate a machine.

        :param hostname: The hostname to match.
        :type hostname: `str`
        :param architectures: The architecture(s) to match.
        :type architectures: sequence of `str`
        :param cpus: The minimum number of CPUs to match.
        :type cpus: `int`
        :param fabrics: The connected fabrics to match.
        :type fabrics: sequence of either `str`, `int`, or `Fabric`
        :param interfaces: The interfaces to match.
        :type interfaces: sequence of either `str`, `int`, or `Interface`
        :param memory: The minimum amount of RAM to match in MiB.
        :type memory: `int`
        :param pod: The pod to allocate the machine from.
        :type pod: `str`
        :param not_pod: Pod the machine must not be located in.
        :type not_pod: `str`
        :param pod_type: The type of pod to allocate the machine from.
        :type pod_type: `str`
        :param not_pod_type: Pod type the machine must not be located in.
        :type not_pod_type: `str`
        :param subnets: The subnet(s) the desired machine must be linked to.
        :type subnets: sequence of `str` or `int` or `Subnet`
        :param storage: The storage contraint to match.
        :type storage: `str`
        :param tags: The tags to match, as a sequence.
        :type tags: sequence of `str`
        :param zone: The zone the desired machine must belong to.
        :type zone: `str` or `Zone`
        :param not_fabrics: The fabrics the machine must NOT be connected to.
        :type not_fabrics: sequence of either `str`, `int`, or `Fabric`
        :param not_subnets: The subnet(s) the desired machine must NOT be
            linked to.
        :type not_subnets: sequence of `str` or `int` or `Subnet`
        :param not_zones: The zone(s) the desired machine must NOT in.
        :type not_zones: sequence of `str` or `Zone`
        :param agent_name: Agent name to attach to the acquire machine.
        :type agent_name: `str`
        :param comment: Comment for the allocate event placed on machine.
        :type comment: `str`
        :param bridge_all: Automatically create a bridge on all interfaces
            on the allocated machine.
        :type bridge_all: `bool`
        :param bridge_stp: Turn spaning tree protocol on or off for the
            bridges created with bridge_all.
        :type bridge_stp: `bool`
        :param bridge_fd: Set the forward delay in seconds on the bridges
            created with bridge_all.
        :type bridge_fd: `int`
        :param dry_run: Don't actually acquire the machine just return the
            machine that would have been acquired.
        :type dry_run: `bool`
        :param verbose: Indicate that the user would like additional verbosity
            in the constraints_by_type field (each constraint will be prefixed
            by `verbose_`, and contain the full data structure that indicates
            which machine(s) matched).
        :type verbose: `bool`