Load a set of conversations by their keys.
320141
def load(cls, keys):
        
        conversations = []
        for key in keys:
            conversation = unitdata.kv().get(key)
            if conversation:
                conversations.append(cls.deserialize(conversation))
        return conversations
626999
def load_keys(path = nil)
        path ||= File.join(@path, @keydir)
        keys = Hash.new {|k,v| k[v] = DirtyProxy.new([])}

        list_keys(path).each do |key|
          new_key = SSHKey.from_file(File.join(path, key))
          owner = new_key.owner

          keys[owner] << new_key
        end
        #Mark key sets as unmodified (for dirty checking)
        keys.values.each{|set| set.clean_up!}

        keys
      end
775314
function(key, replacements) {
        var message = messageMap[key];

        if (replacements) {
            message = util.replaceText(message, replacements);
        }

        return message;
    }
1366253
def load_elements(self, elements):
        ""
        self.pg_no = 0
        self.elements = elements
        self.keys = [v['name'].lower() for v in self.elements]
784039
def consume_keys(self):
        
        print("\nLooking up " + self.input_queue.qsize().__str__() + " keys from " + self.source_name + "\n")
        self.data_worker(**self.worker_args)
949610
def _store(self, messages, response, *args, **kwargs):
        
        return [message for message in messages if not message.level in STICKY_MESSAGE_LEVELS]
33113
def add_items_to_message(msg, log_dict):
    """"""
    out = msg
    for key, value in log_dict.items():
        out += " {}={}".format(key, value)
    return out
1201293
def load(self, data):
        
        objs = {}
        for mapper in self.entities:
            objs[mapper.name] = mapper.load(self.loader, data)

        for mapper in self.relations:
            objs[mapper.name] = mapper.load(self.loader, data, objs)
216959
function iterateKeys(keys) {
    async.forEach(keys, readKey, function (err) {
      return err ? callback(err) : callback(null, keyinfo);
    });
  }
951109
def _load_users(self):
        """"""
        r = sql.abstractRequetesSQL.get_users()()
        self.users = {d["id"]: dict(d) for d in r}
480694
def keys(self, start=None, stop=None):
        """"""
        return (item[0] for item in self.items(start, stop))
233764
def load_lists(keys=[], values=[], name='NT'):
    
    mapping = dict(zip(keys, values))
    return mapper(mapping, _nt_name=name)
379231
public function loadMessages()
    {
        $message = new IncomingMessage(Audio::PATTERN, $this->event->get('from')['id'], $this->event->get('chat')['id'],
            $this->event);
        $message->setAudio($this->getAudio());

        $this->messages = [$message];
    }
815232
def move_conversations(self, ids, folder):
        

        str_ids = self._return_comma_list(ids)
        self.request('ConvAction', {'action': {'op': 'move',
                                               'id': str_ids,
                                               'l': str(folder)}})
485939
def load(self, text, fieldnames=None):
    """"""
    lines = text.split('\n')
    fieldnames = load_line(lines[0])
    values = load_line(lines[1])
    self.__dict__ = dict(zip(fieldnames, values))
84071
def messages(fp, key='@message'):
    
    for line in lines(fp):
        txt = line.rstrip('\n')
        yield {key: txt}
919802
def _handle_chat(self, data):
        """"""

        self.conn.enqueue_data(
            "chat", ChatMessage.from_data(self.room, self.conn, data)
        )