code: async def create(
              cls, node: Union[Node, str], name: str,
              devices: Iterable[Union[BlockDevice, Partition]],
              *, uuid: str = None):
          
          params = {
              'name': name,
          }
          if isinstance(node, str):
              params['system_id'] = node
          elif isinstance(node, Node):
              params['system_id'] = node.system_id
          else:
              raise TypeError(
                  'node must be a Node or str, not %s' % (
                      type(node).__name__))
  
          if len(devices) == 0:
              raise ValueError("devices must contain at least one device.")
  
          block_devices = []
          partitions = []
          for idx, device in enumerate(devices):
              if isinstance(device, BlockDevice):
                  block_devices.append(device.id)
              elif isinstance(device, Partition):
                  partitions.append(device.id)
              else:
                  raise TypeError(
                      "devices[%d] must be a BlockDevice or "
                      "Partition, not %s" % type(device).__name__)
          if len(block_devices) > 0:
              params['block_devices'] = block_devices
          if len(partitions) > 0:
              params['partitions'] = partitions
          if uuid is not None:
              params['uuid'] = uuid
          return cls._object(await cls._handler.create(**params))
docs: Create a volume group on a Node.
  
          :param node: Node to create the interface on.
          :type node: `Node` or `str`
          :param name: Name of the volume group.
          :type name: `str`
          :param devices: Mixed list of block devices or partitions to create
              the volume group from.
          :type devices: iterable of mixed type of `BlockDevice` or `Partition`
          :param uuid: The UUID for the volume group (optional).
          :type uuid: `str`