Bulk copy a set of devices.

        :param ids: Int list of device IDs.
        :return: :class:`devices.Device <devices.Device>` list
348310
def bulk_copy(self, ids):
        
        schema = DeviceSchema()
        return self.service.bulk_copy(self.base, self.RESOURCE, ids, schema)
610326
def ids(cls, values, itype=None):
        '''
        

        '''
        instance = cls(ids={'values': values})
        if itype is not None:
            instance['ids']['type'] = itype

        return instance
732031
def factory_reset(self, ids, except_ids=False, except_baudrate_and_ids=False):
        

        mode = (0x02 if except_baudrate_and_ids else
                0x01 if except_ids else 0xFF)

        for id in ids:
            try:
                self._send_packet(self._protocol.DxlResetPacket(id, mode))

            except (DxlTimeoutError, DxlCommunicationError):
                pass
1330992
def loadImgs(self, ids=[]):
        
        if type(ids) == list:
            return [self.imgs[id] for id in ids]
        elif type(ids) == int:
            return [self.imgs[ids]]
607599
def remove_from_group(self, devices):
        """"""
        ids = {d.id for d in self.devices_in_group()}
        ids.difference_update(self._device_ids(devices))
        self._set_group(ids)
1232422
def copy_keys(source, destination, keys=None):
    
    if keys is None:
        keys = destination.keys()
    for k in set(source) & set(keys):
        destination[k] = source[k]
    return destination
911401
def batch_fetch_labels(ids):
    
    m = {}
    for id in ids:
        label = anyont_fetch_label(id)
        if label is not None:
            m[id] = label
    return m
17509
private void copyObjectIDsToBatch(BatchResult batchResult, DBObjectBatch dbObjBatch) {
        if (batchResult.getResultObjectCount() < dbObjBatch.getObjectCount()) {
            m_logger.warn("Batch result returned fewer objects ({}) than input batch ({})",
                          batchResult.getResultObjectCount(), dbObjBatch.getObjectCount());
        }
        Iterator<ObjectResult> resultIter = batchResult.getResultObjects().iterator();
        Iterator<DBObject> objectIter = dbObjBatch.getObjects().iterator();
        while (resultIter.hasNext()) {
            if (!objectIter.hasNext()) {
                m_logger.warn("Batch result has more objects ({}) than input batch ({})!",
                              batchResult.getResultObjectCount(), dbObjBatch.getObjectCount());
                break;
            }
            ObjectResult objResult = resultIter.next();
            DBObject dbObj = objectIter.next();
            if (Utils.isEmpty(dbObj.getObjectID())) {
                dbObj.setObjectID(objResult.getObjectID());
            } else if (!dbObj.getObjectID().equals(objResult.getObjectID())) {
                m_logger.warn("Batch results out of order: expected ID '{}', got '{}'",
                              dbObj.getObjectID(), objResult.getObjectID());
            }
        }
    }
1284524
def delete(self, ids):
        
        url = build_uri_with_ids('api/v4/ipv4/%s/', ids)

        return super(ApiV4IPv4, self).delete(url)
826386
private static byte[] getIids2(final List<BeanId> ids, final UniqueIds uids) {
        if (ids == null) {
            return new byte[0];
        }
        final AbstractList<String> list = new AbstractList<String>() {

            @Override
            public String get(int index) {
                return ids.get(index).getInstanceId();
            }

            @Override
            public int size() {
                return ids.size();
            }
        };
        return getIids(list, uids);
    }
486673
def get_many(self, ids):
        """"""
        return [self.instance(id, **fields)
                    for id, fields in zip(ids, self.api.mget(ids))]
1303709
public List<UserDto> selectByIds(DbSession session, Collection<Integer> ids) {
    return executeLargeInputs(ids, mapper(session)::selectByIds);
  }
785116
public GetDevicesInPlacementResult withDevices(java.util.Map<String, String> devices) {
        setDevices(devices);
        return this;
    }
970208
def convert_ids_to_tokens(self, ids):
        """"""
        tokens = []
        for i in ids:
            tokens.append(self.ids_to_tokens[i])
        return tokens
162342
public Collection<C> getAll(Collection<String> ids){
		Set<C> list = new LinkedHashSet<C>();

		for(String id : ids){
			C container = get(id);

			if(container != null){
				list.add(container);
			}
		}

		return list;
	}
1358927
def scan(self, ids=range(254)):
        
        return [id for id in ids if self.ping(id)]
499802
def bulk_export(self, ids, exclude_captures=False):
        
        return self.service.bulk_export(self.base, ids, params={'exclude_captures': exclude_captures})