Python jsonpickle.decode() Examples

def _load():
    def load_stock_weapons():
        with open('dueutil/game/configs/defaultweapons.json') as defaults_file:
            defaults = json.load(defaults_file)
            for weapon_name, weapon_data in defaults.items():
                stock_weapons.append(weapon_name)
                Weapon(weapon_data["name"],
                       weapon_data["useText"],
                       weapon_data["damage"],
                       weapon_data["accy"],
                       icon=weapon_data["icon"],
                       image_url=weapon_data["image"],
                       melee=weapon_data["melee"],
                       no_save=True)

    load_stock_weapons()

    # Load from db
    for weapon in dbconn.get_collection_for_object(Weapon).find():
        loaded_weapon = jsonpickle.decode(weapon['data'])
        weapons[loaded_weapon.id] = util.load_and_update(NO_WEAPON, loaded_weapon)
    util.logger.info("Loaded %s weapons", len(weapons)) 

def __init__(self, file, error_on_decode=False, ctx=None):
        proscli.utils.debug('Opening {} ({})'.format(file, self.__class__.__name__), ctx=ctx)
        self.save_file = file   # type: str
        self.__ignored = ['save_file', '_Config__ignored']  # type: list(str)
        if file:
            if os.path.isfile(file):
                with open(file, 'r') as f:
                    try:
                        self.__dict__.update(jsonpickle.decode(f.read()).__dict__)
                    except (json.decoder.JSONDecodeError, AttributeError):
                        if error_on_decode:
                            raise
                        else:
                            pass
            elif os.path.isdir(file):
                raise ValueError('{} must be a file, not a directory'.format(file))
            else:
                try:
                    self.save()
                except Exception:
                    pass 

def load_chain(current_port, nodes=None):
    all_blocks = []
    from requests.exceptions import ConnectionError
    import jsonpickle
    for node in nodes:
        try:
            # kendi kendisine chain sormaması için.
            if node != current_port:
                http_response = requests.get(
                    'http://localhost:{0}/chain'.format(node))
                serialized = http_response.json()['blocks']
                thawed = jsonpickle.decode(serialized)

                all_blocks.append((node, thawed))
        except ConnectionError as conerr:
            _log('info', '{0} porta sahip node offline olabilir'.format(node))

    active_node.load_chain(all_blocks) 

def load(self, cfgf, prefix=None):
        if self.dataLoaded:
            return

        if prefix != None:
            self.certsDir = prefix + '/etc/ca/certs'
            if not os.path.exists(self.certsDir):
                log.L.error('Certs directory does not exist or is unreadable (%s)!' % self.certsDir)
                log.L.error('Make sure you ran `make install` without errors.')
                self.certsDir = None

        if (self.configFile is None):
            self.configFile = cfgf
        try:
            if (self.configFile != None):
                f = open(self.configFile, 'r')
                jsonStr = f.read()
                f.close()
                self.data = jsonpickle.decode(jsonStr)
            self.dataLoaded = True            
        except IOError:
            log.L.error("Cannot read SDP file %s" % (self.configFile)) 

def read_dictionary(self, providers=None):

        config_dir = user_config_dir()
        filename = os.path.join(config_dir, 'QTable.json')

        if not os.path.exists(filename):
            # TODO: check if it will not affect anything
            self.self_state = VPSState(provider="blueangelhost", option="Basic Plan")
            self.init_qtable_and_environment(providers)
            self.create_initial_tree()
            self.write_dictionary()
        else:
            with open(filename) as json_file:
                data_encoded = json.load(json_file)
                data = jsonpickle.decode(data_encoded)
                self.environment = data['environment']
                self.qtable = data['qtable']
                self.providers_offers = data['providers_offers']
                self.self_state = data['self_state']
                self.tree = data['tree'] 

def check_queue():
	await bot.wait_until_ready()
	while not bot.is_closed:
		queue = await get_queue()
		if len(queue) == 0:
			await asyncio.sleep(1)
		else:
			for s in queue:
				message_id = int(s)
				channel_id = str(queue[s][0])
				message = str(queue[s][1])
				embed = True if int(queue[s][3]) else False
				try:
					target = bot.get_channel(channel_id)
					if embed:
						await bot.send_message(target, embed=jsonpickle.decode(message))
					else:
						await truncate(target, message)
				except Exception as e:
					print(e)
					pass
				delete_request = await delete_queue(message_id)
				await asyncio.sleep(0.21) 

def call_method_post(self, method, json_scheme, debug=False):
        url = '{}/{}'.format(self.wcf_baseurl, method)
        headers = {'Content-Type': 'application/json', 'Content-Length': str(len(json_scheme))}
        response = Http.post(url=url, data=json_scheme, headers=headers)
        parsed_response = json.loads(response.content.decode('utf-8'))
        if response.status_code != 200:
            from ArubaCloud.base.Errors import MalformedJsonRequest
            raise MalformedJsonRequest("Request: {}, Status Code: {}".format(json_scheme, response.status_code))
        if parsed_response['Success'] is False:
            from ArubaCloud.base.Errors import RequestFailed
            raise RequestFailed("Request: {}, Response: {}".format(json_scheme, parsed_response))
        if debug is True:
            msg = "Response Message: {}\nHTTP Status Code: {}".format(parsed_response, response.status_code)
            self.logger.debug(msg)
            print(msg)
        return parsed_response 

def _commit(self):
        """
        :return: (dict) Response object content
        """
        assert self.uri is not None, Exception("BadArgument: uri property cannot be None")
        url = '{}/{}'.format(self.uri, self.__class__.__name__)
        serialized_json = jsonpickle.encode(self, unpicklable=False, )
        headers = {'Content-Type': 'application/json', 'Content-Length': str(len(serialized_json))}
        response = Http.post(url=url, data=serialized_json, headers=headers)
        if response.status_code != 200:
            from ArubaCloud.base.Errors import MalformedJsonRequest
            raise MalformedJsonRequest("Request: {}, Status Code: {}".format(serialized_json, response.status_code))
        content = jsonpickle.decode(response.content.decode("utf-8"))
        if content['ResultCode'] == 17:
            from ArubaCloud.base.Errors import OperationAlreadyEnqueued
            raise OperationAlreadyEnqueued("{} already enqueued".format(self.__class__.__name__))
        if content['Success'] is False:
            from ArubaCloud.base.Errors import RequestFailed
            raise RequestFailed("Request: {}, Response: {}".format(serialized_json, response.content))
        return content 

def __init__(self):
        configureLogging()
        self.logger = getLogger(with_console=True)
        get_packet_logger(with_console=True)
        self.logger.info("mq operator is starting")

        with open("settings.json", "r") as stream:
            lines = stream.read()
            txt = ""
            for line in lines:
                txt = txt + line
        self.configuration = jsonpickle.decode(txt)
        self.client = mqtt.Client(client_id=self.configuration.mqtt_clientid, protocol=mqtt.MQTTv311)
        self.client.on_connect = self.on_connect
        self.client.on_disconnect = self.on_disconnect
        self.client.on_message = self.on_message
        self.client.tls_set(ca_certs="/etc/ssl/certs/DST_Root_CA_X3.pem")
        self.i_pdm = None
        self.i_pod = None
        self.g_pdm = None
        self.g_pod = None
        self.rate_requested = None
        self.rate_request_lock = Lock()
        self.rate_check_lock = Lock()
        self.rate_check_event = Event() 

def decode(self, feature_vec, input_features, ndigits=8):
        """Reverse operation to binary_encoded_features

        :param feature_vec: binary feature vector
        :return: dictionary of active features, with their associated confidence
        """

        reversed_features = []
        for bf in feature_vec:
            if np.sum(np.where(bf > 0.)) > 0:
                active_features = np.argwhere(bf > 0.)
                feature_tuples = []
                for feature in active_features:
                    feat_name = list(input_features)[feature[0]]
                    if ndigits is not None:
                        feat_value = round(bf[feature[0]], ndigits)
                    else:
                        feat_value = bf[feature[0]]
                    feature_tuples.append((feat_name, feat_value))
                reversed_features.append(feature_tuples)
            else:
                reversed_features.append(None)
        return reversed_features 

def decode(self, feature_vec, input_features, ndigits=8):
        """Reverse operation to binary_encoded_features

        :param feature_vec: binary feature vector
        :param input_features: list of all features
        :param ndigits: ignored
        :return: dictionary of active features
        """

        reversed_features = []
        for bf in feature_vec:
            if np.sum(np.where(bf == 1)) > 0:
                feature_tuples = []
                feat_names = list(np.array(input_features)[np.where(bf == 1)])
                for feat_name in feat_names:
                    feature_tuples.append((feat_name, 1))
                reversed_features.append(feature_tuples)
            else:
                reversed_features.append(None)
        return reversed_features 

def _load():
    def load_default_quests():
        with open('dueutil/game/configs/defaultquests.json') as defaults_file:
            defaults = json.load(defaults_file)
            for quest_data in defaults.values():
                Quest(quest_data["name"],
                      quest_data["baseAttack"],
                      quest_data["baseStrg"],
                      quest_data["baseAccy"],
                      quest_data["baseHP"],
                      task=quest_data["task"],
                      weapon_id=weapons.stock_weapon(quest_data["weapon"]),
                      image_url=quest_data["image"],
                      spawn_chance=quest_data["spawnChance"],
                      no_save=True)

    load_default_quests()

    for quest in dbconn.get_collection_for_object(Quest).find():
        loaded_quest = jsonpickle.decode(quest['data'])
        quest_map[loaded_quest.id] = util.load_and_update(REFERENCE_QUEST, loaded_quest)
    util.logger.info("Loaded %s quests", len(quest_map)) 

def deserialize(self):
        cache_loaded = False
        if os.path.exists(self.server_fname()) and not os.path.isdir(self.backup):
            try:
                self.memcache = { "server" : {},
                                  "users" : {} }
                
                with open(self.server_fname()) as backupfile:
                    print ("Attempting to reload cache")
                    self.memcache['server'] = jsonpickle.decode(backupfile.read())

                print ("Server cache loaded", json.dumps(self.memcache, indent=4))
                for user in self.memcache['server']['user_list']:
                    # Try to load as much user data as possible
                    if os.path.exists(self.user_fname(user)):
                        print ("found path for user", user)
                        with open(self.user_fname(user)) as userfile:
                            user_data = jsonpickle.decode(userfile.read())
                        self.memcache['users'][user] = user_data
                cache_loaded = True
            except Exception as e:
                print ("Cache file corrupted...")
                raise e
        if not cache_loaded:
            print ("Cache could not be loaded")
            pass
        else:
            print ("CACHE LOADED SUCCESSFULLY!") 

def from_json_str(self, s):
        return jsonpickle.decode(s) 

def deserialize(pack_manager: PackManager, string: str):
    r"""Deserialize a pack from a string.
    """
    pack = jsonpickle.decode(string)
    # Need to assign the pack manager to the pack to control it after reading
    #  the raw data.
    # pylint: disable=protected-access
    pack._pack_manager = pack_manager
    pack_manager.set_remapped_pack_id(pack)
    return pack 

def __getitem__(self, key):
        ''' Method to support region[key] notion '''
        url = self.base_url + "/" + str(key) + "?ignoreMissingKey=true"
        data = requests.get(url, auth=(self.user, self.password))
        logging.debug("Sending request to " + url)
        if data.status_code == 200:
            logging.debug("Response from server: " + " ,".join(data))
            return jsonpickle.decode(data.text)
        else:
            self.error_response(data) 

def _get_flow_for_token(csrf_token, request):
    """ Looks up the flow in session to recover information about requested
    scopes.

    Args:
        csrf_token: The token passed in the callback request that should
            match the one previously generated and stored in the request on the
            initial authorization view.

    Returns:
        The OAuth2 Flow object associated with this flow based on the
        CSRF token.
    """
    flow_pickle = request.session.get(_FLOW_KEY.format(csrf_token), None)
    return None if flow_pickle is None else jsonpickle.decode(flow_pickle) 

def remove_listener(self, function):
        """Remove a function from the execution schedule of a worker upon msg.
        Workers' functions must be unique by name."""
        if isinstance(function, dict):
            fun_bytes = jsonpickle.decode(json.dumps(function))
            function = cloudpickle.loads(fun_bytes)
        for func in self.funcs_to_execute:
            if func.__name__ == function.__name__:
                self.funcs_to_execute.remove(func)
                return True
        return False 

def _parse(cls, data):
        """Parse JSON string and return data"""
        try:
            return jsonpickle.decode(data)
        except ValueError as err:
            log.exception('Error creating %s from json.', cls.__name__)
            raise err 

def on_message(self, client, userdata, message: mqtt.MQTTMessage):
        ratestr = message.payload.decode()
        self.logger.info("Message %s %s %s " % (message.topic, message.timestamp, ratestr))
        try:
            ratespl = ratestr.split(' ')
            rate1 = Decimal(ratespl[0])
            rate2 = Decimal(ratespl[1])
            self.set_rate(rate1, rate2)
        except:
            self.send_msg("failed to parse message") 

def _python_decode(obj):
    return jsonpickle.decode(json.dumps(obj)) 

def block_added():
    import jsonpickle
    serialized = request.json['block']
    thawed = jsonpickle.decode(serialized)
    active_node.block_added(thawed)
    _log('debug', 'Başka bir miner block problemini çözdü. Çözülen block, chain\'e eklendi.')
    return jsonify({'status': 'ok'}) 

def deserialize(encoded, **kwargs):
    """Construct a muda transformation from a JSON encoded string.

    Parameters
    ----------
    encoded : str
        JSON encoding of the transformation or pipeline

    kwargs
        Additional keyword arguments to `jsonpickle.decode()`

    Returns
    -------
    obj
        The transformation

    See Also
    --------
    serialize

    Examples
    --------
    >>> D = muda.deformers.TimeStretch(rate=1.5)
    >>> D_serial = muda.serialize(D)
    >>> D2 = muda.deserialize(D_serial)
    >>> D2
    TimeStretch(rate=1.5)
    """

    params = jsonpickle.decode(encoded, **kwargs)

    return __reconstruct(params) 

def load(path) -> Optional["TrackerFeaturizer"]:
        """Loads the featurizer from file."""

        featurizer_file = os.path.join(path, "featurizer.json")
        if os.path.isfile(featurizer_file):
            return jsonpickle.decode(rasa.utils.io.read_file(featurizer_file))
        else:
            logger.error(
                "Couldn't load featurizer for policy. "
                "File '{}' doesn't exist.".format(featurizer_file)
            )
            return None 

def get(self, key):
        if not self._is_valid_key(key):
            return
        result = self._get(self._qualified_key(key))
        if self.auto_casting and (result is not None):
            result = jsonpickle.decode(result)
        return result 

def set_state(self, state):
        state = state.decode('utf-8')
        value = jsonpickle.decode(state)
        self._start_date = value['start_date']
        self._static_unit_net_value = value['static_unit_net_value']
        self._units = value['units']
        for k, v in six.iteritems(value['accounts']):
            self._accounts[k].set_state(v) 

def load_player(player_id):
    response = dbconn.get_collection_for_object(Player).find_one({"_id": player_id})
    if response is not None and 'data' in response:
        player_data = response['data']
        loaded_player = jsonpickle.decode(player_data)
        players[loaded_player.id] = util.load_and_update(REFERENCE_PLAYER, loaded_player)
        return True 

def load(self, dump_filename: str):
        with open(dump_filename, "r") as f:
            vectorizer = jsonpickle.decode(f.read())
            self.__dict__.update(vectorizer.__dict__) 

def from_json_str(self, s):
        return jsonpickle.decode(s) 

def loads(json, **args):
    return jsonpickle.decode(json)