Bulk copy a set of users.

        :param ids: Int list of user IDs.
        :return: :class:`users.User <users.User>` list
322497
def bulk_copy(self, ids):
        
        schema = UserSchema()
        return self.service.bulk_copy(self.base, self.RESOURCE, ids, schema)
354481
def populate(self):
        
        server, IPAddresses, storages = self.cloud_manager.get_server_data(self.uuid)
        self._reset(
            server,
            ip_addresses=IPAddresses,
            storage_devices=storages,
            populated=True
        )
        return self
1047077
def user_ids=(values)
      values ||= []
      values = [ values ] unless values.is_a?(::Array)
      values = values.reject{|v| v.blank?}.map{|v| v.to_i}
      self.users = Incline::User.where(id: values).to_a
    end
273625
def by_user(self):  # pragma: no cover
        
        users = [i for i in self.__get_users()]
        user_groups = {}
        group_results = {
            tuple(value): key
            for (key, value) in self.by_group().items()
        }
        for user in users:
            user_groups[user] = []
            for user_list, group in group_results.items():
                if user in user_list:
                    user_groups[user].append(group)

        return user_groups
869033
def move_users(self, user_id_list, group_id):
        
        return self.post(
            url="https://api.weixin.qq.com/cgi-bin/groups/members/batchupdate",
            data={
                "openid_list": user_id_list,
                "to_groupid": group_id
            }
        )
1137476
def bulk_upsert(self, docs, namespace, timestamp):
        
        for doc in docs:
            self.upsert(doc, namespace, timestamp)
694849
def bulk_copy(self, ids):
        
        schema = PackageSchema()
        return self.service.bulk_copy(self.base, self.RESOURCE, ids, schema)
1374616
def ids_to_s(ids)
      if ids.is_a?(Array)
        s = ids.each { |i| id_to_s(i) }.join(', ')
        s.size > 1000 ? "[#{s[0, 1000]}...]" : "[#{s}]"
      else
        id_to_s(ids)
      end
    end
951109
def _load_users(self):
        """"""
        r = sql.abstractRequetesSQL.get_users()()
        self.users = {d["id"]: dict(d) for d in r}
1050212
public List<T> list(List<Long> ids)
    {
        List<T> ret = new ArrayList<T>();

        if(ids != null)
        {
            for(Long id : ids)
            {
                T resource = get(id);
                if(resource != null)
                    ret.add(resource);
            }
        }

        return ret;
    }
519810
def create_from_ids(self,list_ids):
        
        for this_id in list_ids:
            new_target = Ctarget()
            new_target.set_id(this_id)
            self.node.append(new_target.get_node())
450020
def get_users_by_ids(self, user_ids):
        
        urls = [urljoin(self.user_url, F"{i}.json") for i in user_ids]
        result = self._run_async(urls=urls)
        return [User(r) for r in result if r]
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
1115514
def _expand_users(device_users, common_users):

    ''''''

    expected_users = deepcopy(common_users)
    expected_users.update(device_users)

    return expected_users
685176
def _get_id2obj_high(self, id2obj_user, id_sources, fnc_fill):
        """"""
        for idid_user in id_sources:
            idobj_user = self.id2obj_all[idid_user]
            fnc_fill(id2obj_user, idobj_user)
            id2obj_user[idobj_user.item_id] = idobj_user
            if idid_user != idobj_user.item_id:
                id2obj_user[idid_user] = idobj_user
1232447
def credential_share(self, cred_id, *user_ids):
        
        return self.raw_query("credential", "share", data={
            'id': cred_id,
            'users': [{'id': i} for i in user_ids],
        })
1151699
def chain_user_names(users, exclude_user, truncate=35):
    """"""
    if not users or not isinstance(exclude_user, get_user_model()):
        return ''
    return truncatechars(
        ', '.join(u'{}'.format(u) for u in users.exclude(pk=exclude_user.pk)),
        truncate)