Python cbor.dumps方法代码示例

# 需要导入模块: import cbor [as 别名]
# 或者: from cbor import dumps [as 别名]
def send(self):
        name = uuid4().hex[:20]
        txns = [
            self._factory.create_transaction(
                cbor.dumps({
                    'Name': name,
                    'Verb': 'set',
                    'Value': 1000
                }),
                inputs=[
                    self._namespace + self._factory.sha512(name.encode())[-64:]
                ],
                outputs=[
                    self._namespace + self._factory.sha512(name.encode())[-64:]
                ],
                deps=[])
        ]
        self._rest.send_batches(self._factory.create_batch(txns)) 

# 需要导入模块: import cbor [as 别名]
# 或者: from cbor import dumps [as 别名]
def serialize_to_bytes(self):
        """Serialized the consensus state object to a byte string suitable
        for storage

        Returns:
            bytes: serialized version of the consensus state object
        """
        # For serialization, the easiest thing to do is to convert ourself to
        # a dictionary and convert to CBOR.  The deque object cannot be
        # automatically serialized, so convert it to a list first.  We will
        # reconstitute it to a deque upon parsing.
        self_dict = {
            '_aggregate_local_mean': self._aggregate_local_mean,
            '_population_samples': list(self._population_samples),
            '_total_block_claim_count': self._total_block_claim_count,
            '_validators': self._validators
        }
        return cbor.dumps(self_dict) 

# 需要导入模块: import cbor [as 别名]
# 或者: from cbor import dumps [as 别名]
def test_receipt_stored(self):
        """Tests that receipts are stored successfully when a block is
        committed."""
        self._subscribe()
        n = self.batch_submitter.submit_next_batch()
        response = self._get_receipt(n)
        receipts = self.assert_receipt_get_response(response)
        state_change = receipts[0].state_changes[0]
        self.assertEqual(
            state_change.type,
            transaction_receipt_pb2.StateChange.SET)
        self.assertEqual(
            state_change.value,
            cbor.dumps({str(n): 0}))
        self.assertEqual(
            state_change.address,
            make_intkey_address(str(n)))
        self._unsubscribe() 

# 需要导入模块: import cbor [as 别名]
# 或者: from cbor import dumps [as 别名]
def build_test_data(destdir):
    l = get_test_data_list()
    for i in range(len(l)):
        # packer = msgpack.Packer()
        serialized = msgpack.dumps(l[i])
        f = open(os.path.join(destdir, str(i) + '.msgpack.golden'), 'wb')
        f.write(serialized)
        f.close()
        serialized = cbor.dumps(l[i])
        f = open(os.path.join(destdir, str(i) + '.cbor.golden'), 'wb')
        f.write(serialized)
        f.close() 

# 需要导入模块: import cbor [as 别名]
# 或者: from cbor import dumps [as 别名]
def to_cbor_bytes(self):
        return cbor.dumps(self.to_map(), sort_keys=True) 

# 需要导入模块: import cbor [as 别名]
# 或者: from cbor import dumps [as 别名]
def bytes_for_object(obj):
    try:
        return obj.to_cbor_bytes()
    except AttributeError:
        pass

    if isinstance(obj, dict):
        try:
            return cbor.dumps(obj)
        except ValueError:
            pass
    return obj 

# 需要导入模块: import cbor [as 别名]
# 或者: from cbor import dumps [as 别名]
def insert_canonical(self, record, timeout=TIMEOUT_SECS):
        try:
            cbor_bytes = record.to_cbor_bytes()
        except AttributeError:
            cbor_bytes = cbor.dumps(record)

        req = Transactor_pb2.InsertRequest(canonicalCbor=cbor_bytes)
        ref = with_retry(self.client.InsertCanonical, req, timeout)
        return MultihashReference.from_base58(ref.reference) 

# 需要导入模块: import cbor [as 别名]
# 或者: from cbor import dumps [as 别名]
def update_chain(self, cell, timeout=TIMEOUT_SECS):
        try:
            cbor_bytes = cell.to_cbor_bytes()
        except AttributeError:
            cbor_bytes = cbor.dumps(cell)

        req = Transactor_pb2.UpdateRequest(chainCellCbor=cbor_bytes)
        ref = with_retry(self.client.UpdateChain, req, timeout)
        return MultihashReference.from_base58(ref.reference) 

# 需要导入模块: import cbor [as 别名]
# 或者: from cbor import dumps [as 别名]
def _init_drsocks(i):
    """Internal use only"""
####################################
# Initialise TCP sockets to receive#
# unicast Discovery responses      # 
####################################

    # Can't use a comprehension because we need the actual
    # list index in order select the correct socket.
    _msg_bytes = cbor.dumps([M_NOOP]) #No-op message
    for _ in range(10):
        try:
            _mcssocks[i][1].sendto(_msg_bytes,0,(str(ALL_GRASP_NEIGHBORS_6), GRASP_LISTEN_PORT))
            _port = _mcssocks[i][1].getsockname()[1]
            _s =socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
            _s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
            try:
                #ttprint("Binding",_port)
                _s.bind(('',_port))
            except:
                # Can't get the same port number, try again
                #ttprint("Couldn't bind")
                _s.close()              
                _mcssocks[i][1].close()
                ifi = _mcssocks[i][0]
                _mcssocks[i][1] = _try_mcsock(ifi)
                continue
            _drlt = _drlisten(_s, _ll_zone_ids[i][0])
            tprint("Starting a discovery TCP listener for interface", _s.getsockname(), _ll_zone_ids[i][0])
            _drlt.start()
            return
        except OSError as ex:
            ttprint(ex)
            #Network down, most likely, wait and retry
            tprint("Retrying to start discovery listener")
            time.sleep(10)
    # If we're here, something is deeply suspect and we have to give up.
    raise RuntimeError("Cannot get free port for discovery TCP listener") 

# 需要导入模块: import cbor [as 别名]
# 或者: from cbor import dumps [as 别名]
def flush_block(self, block):
        block_data = b''
        if block.data is not None:
            block_data = self.codec.encode_block(block.id, block.data)
        assert isinstance(block_data, bytes)
        data = cbor.dumps([block_data, block.refcnt, block.type])
        with self.env.begin(db=self.block_db, write=True) as t:
            if t.get(block.id) == data:
                return 0
            t.put(block.id, data)
            return 1 

# 需要导入模块: import cbor [as 别名]
# 或者: from cbor import dumps [as 别名]
def dumps(self, o):
        return cbor.dumps(self.get_external_dict(o)) 

# 需要导入模块: import cbor [as 别名]
# 或者: from cbor import dumps [as 别名]
def _dumps(obj):
    return json.dumps(obj,
                      separators=(',', ':'),
                      ensure_ascii=False,
                      sort_keys=False,
                      cls=_WAMPJsonEncoder) 

# 需要导入模块: import cbor [as 别名]
# 或者: from cbor import dumps [as 别名]
def serialize(self, obj):
            """
            Implements :func:`autobahn.wamp.interfaces.IObjectSerializer.serialize`
            """
            data = cbor.dumps(obj)
            if self._batched:
                return struct.pack("!L", len(data)) + data
            else:
                return data 

# 需要导入模块: import cbor [as 别名]
# 或者: from cbor import dumps [as 别名]
def main():
    p = argparse.ArgumentParser('simple debugging tool for watching the linker and OpenQuery')
    p.add_argument('action', help='either `run` or `cache` or `delete`')
    p.add_argument('folder', help='folder name')
    p.add_argument('subfolder', help='subfolder name')
    args = yakonfig.parse_args(p, [kvlayer, yakonfig])

    config = yakonfig.get_global_config()

    key = cbor.dumps((args.folder.replace(' ', '_'), args.subfolder.replace(' ', '_')))

    if args.action == 'run':
        web_conf = Config()
        with yakonfig.defaulted_config([kvlayer, dblogger, web_conf], config=config):
            traverse_extract_fetch(web_conf, key, stop_after_extraction=True)

    elif args.action == 'delete':
        kvlclient = kvlayer.client()
        kvlclient.setup_namespace({'openquery': (str,)})
        kvlclient.delete('openquery', (key,))
        print('deleted %r' % key)

    elif args.action == 'cache':

        kvlclient = kvlayer.client()
        kvlclient.setup_namespace({'openquery': (str,)})
        count = 0
        for rec in kvlclient.scan('openquery'):
            count += 1
            if rec[0][0] == key:
                print rec
        print('%d cached queries' % count) 

# 需要导入模块: import cbor [as 别名]
# 或者: from cbor import dumps [as 别名]
def to_kvlayer(item):
        data = cbor.dumps({
            'is_folder': item.is_folder(),
            'meta_data': item.meta_data,
            'user_data': item.data,
        })
        return ((utf8(item.namespace), utf8(item.owner), item.inode), data)