payloads : typing.Sequence[~Payload]
        Returns -> typing.Sequence[~PayloadResult]
187261
async def Track(self, payloads):
        '''
        
        '''
        # map input types to rpc msg
        _params = dict()
        msg = dict(type='PayloadsHookContext',
                   request='Track',
                   version=1,
                   params=_params)
        _params['payloads'] = payloads
        reply = await self.rpc(msg)
        return reply
712297
def _sequence_query(self):
        
        klass = self.__class__
        query = klass.select().where(klass.sequence.is_null(False))
        seq_scope_field_names =\
            (self.__seq_scope_field_name__ or '').split(',')
        for name in seq_scope_field_names:
            seq_scope_field = getattr(klass, name, None)
            if seq_scope_field:
                seq_scope_field_value = getattr(self, name)
                query = query.where(seq_scope_field == seq_scope_field_value)
        return query
1240581
function Sequence (opts) {
    if (opts.actions) {
        return initWithActions(Object.getPrototypeOf(this).constructor, opts.actions)
    }

    if (!opts.one) {
        throw "Sequence argument one must be non-nil"
    }
    if (!opts.two) {
        throw "Sequence argument two must be non-nil"
    }
    this.actions = []

    var d = opts.one.duration + opts.two.duration

    Sequence.superclass.constructor.call(this, {duration: d})

    this.actions[0] = opts.one
    this.actions[1] = opts.two
}
1226537
def _gen_header(self, sequence, payloadtype):
        
        protocol = bytearray.fromhex("00 34")
        source = bytearray.fromhex("42 52 4b 52")
        target = bytearray.fromhex("00 00 00 00 00 00 00 00")
        reserved1 = bytearray.fromhex("00 00 00 00 00 00")
        sequence = pack("<B", sequence)
        ack = pack(">B", 3)
        reserved2 = bytearray.fromhex("00 00 00 00 00 00 00 00")
        packet_type = pack("<H", payloadtype)
        reserved3 = bytearray.fromhex("00 00")

        # assemble header
        header = bytearray(protocol)
        header.extend(source)
        header.extend(target)
        header.extend(reserved1)
        header.extend(ack)
        header.extend(sequence)
        header.extend(reserved2)
        header.extend(packet_type)
        header.extend(reserved3)

        return header
931972
def text(self):
        
        if isinstance(self._value, CommentedMap):
            raise TypeError("{0} is a mapping, has no text value.".format(repr(self)))
        if isinstance(self._value, CommentedSeq):
            raise TypeError("{0} is a sequence, has no text value.".format(repr(self)))
        return self._text
388305
def to_api_repr(self):
        
        info = super(TextEntry, self).to_api_repr()
        info["textPayload"] = self.payload
        return info
662167
def parse_payload(data, payload_fmt, *payload_names):
    
    payload = struct.unpack(payload_fmt, data)
    return dict(zip(payload_names, payload))
543865
def sequence(self):
        
        self.open()
        seq = lvm_vg_get_seqno(self.handle)
        self.close()
        return seq
1348806
def guess_payload_class(self, payload):
        
        for t in self.aliastypes:
            for fval, cls in t.payload_guess:
                if all(hasattr(self, k) and v == self.getfieldval(k)
                       for k, v in six.iteritems(fval)):
                    return cls
        return self.default_payload_class(payload)
858268
def get_seq_seq(self,obj,default=None):
        """"""
        if is_sequence2(obj):
            return [self.get_seq(o,default) for o in obj]
        else:
            return [self.get_seq(obj,default)]
229473
def get_payload(self):
        
        temp = self.get_uri_as_list()
        query_string = temp[4]
        if query_string == "":
            return None  # Bad request error code
        query_string_as_list = str.split(query_string, "=")
        return query_string_as_list[1]
827182
async def get_data(self, raw: bool=True) -> AnyStr:
        """"""
        if self.implicit_sequence_conversion:
            self.response = self.data_body_class(await self.response.convert_to_sequence())
        result = b'' if raw else ''
        async with self.response as body:  # type: ignore
            async for data in body:
                if raw:
                    result += data
                else:
                    result += data.decode(self.charset)
        return result
329380
def filter_sequences(self, seq_type):
        
        return DictList(x for x in self.sequences if isinstance(x, seq_type))
334745
function (uses, payload, message) {
        var results = [];
        var keys = (uses || []);
        for (var i = 0; i < forced.length; ++i) {
            if (keys.indexOf(forced[i]) === -1) {
                keys.push(forced[i]);
            }
        }

        for (var i = 0; i < keys.length; ++i) {
            if (middlewares[keys[i]] !== undefined) {
                results.push({
                    method: middlewares[keys[i]],
                    params: [payload, message]
                });
            }
        }

        return results;
    }
1106233
function get_sequence(self, weight) {
  if (undefined === self.__sequences__[weight]) {
    self.__sequences__[weight] = [];
  }

  return self.__sequences__[weight];
}
981282
def query_sequence(self):
    
    if not self.entries.seq: return None
    if self.check_flag(0x10): return rc(self.entries.seq)
    return self.entries.seq
1210508
async def type_cast_payload(schema: dict, payload: dict):
    
    # In ideal case this should be done using serializer. A temp measure right now
    cerberus_type_map = {
        'string': str,
        'integer': int,
        'float': float,
    }
    for field, validator in schema.items():
        field_type = validator['type']
        if field_type in ['integer', 'string', 'float']:
            payload_value = payload.get(field)
            if not payload_value:
                break
            try:
                payload[field] = cerberus_type_map[field_type](payload_value)
            except ValueError:
                break
    return payload