Python json.JSONDecodeError() Examples

The following are code examples for showing how to use json.JSONDecodeError(). They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don't like. You can also save this page to your account.

Example 1
Project: bitcoin-trading-system   Author: vinicius-ronconi   File: executor.py    (GNU General Public License v3.0) View Source Project 7 votes vote down vote up
def execute(self):
        try:
            self.system.run()
        except (ReadTimeout, ConnectionError, JSONDecodeError):
            pass
        except exceptions.TradingSystemException as e:
            curr = datetime.now()
            print('{time} - {text}'.format(time=curr.strftime('%Y-%m-%d %H:%M:%S'), text=str(e)))
        except Exception as e:
            curr = datetime.now()
            print('{time} - {text} - {args}'.format(time=curr.strftime('%Y-%m-%d %H:%M:%S'), text=str(e), args=e.args))
            traceback.print_exc()

        if self.interval:
            threading.Timer(self.interval, self.execute).start() 
Example 2
Project: pyTBA   Author: Thing342   File: api.py    (GNU General Public License v3.0) View Source Project 6 votes vote down vote up
def tba_get(self, path):
        """Base method for querying the TBA API. Returns the response JSON as a python dict.
        :param path: (str) Request path, without the API address prefix (https://www.thebluealliance.com/api/v2/)
        :return: A dict parsed from the response from the API.
        """

        if self.app_id['X-TBA-App-Id'] == "":
            raise Exception('An API key is required for TBA. Please use set_api_key() to set one.')

        url_str = 'https://www.thebluealliance.com/api/v2/' + path
        r = self.session.get(url_str, headers=self.app_id)
        # print(r.url)
        tba_txt = r.text
        try:
            return json.loads(tba_txt)
        except json.JSONDecodeError:
            print(url_str)
            print(tba_txt) 
Example 3
Project: SuperPACs   Author: SpencerNorris   File: parse_indepexpends.py    (Apache License 2.0) View Source Project 6 votes vote down vote up
def donations_helper():
    print("donations_helper")
    FecApiObj = FECAPI(FEC_APIKEY)
    committees = FecApiObj.get_committees()
    PPCampFinObj = CampaignFinanceAPI(ProPublica_APIKEY)
    PPCongressApi = CongressAPI(ProPublica_APIKEY)
    legislator_index = dict()
    legislators = PPCongressApi.list_members('house')["results"][0]["members"]
    for legislator in legislators:
        name = str(legislator['first_name']) + " " + str(legislator['last_name'])
        legislator_index[name] = legislator
    legislators = PPCongressApi.list_members('senate')["results"][0]["members"]
    for legislator in legislators:
        name = str(legislator['first_name']) + " " + str(legislator['last_name'])
        legislator_index[name] = legislator
    print("starting to iterate through superpacs")
    donations = []
    count = 0
    for committee in committees:
        if(2016 in committee['cycles']):
            try:
                indepExpend = PPCampFinObj.get_indep_expends(str(committee['committee_id']))

                for expend in indepExpend["results"]:
                    try:
                        #expend fo a particular expenditure
                        expend['committee_id'] = str(committee['committee_id'])
                        expend['propublica_candidate_id'] = str(legislator_index[expend['candidate_name']]['id'])
                        donations.append(expend)
                    except KeyError:
                        pass
            except JSONDecodeError:
                pass
            count += 1
    return donations 
Example 4
Project: PyPlanet   Author: PyPlanet   File: json.py    (license) View Source Project 6 votes vote down vote up
def load(self):
		# Prepare + load directory.
		super().load()

		# Load the files and parse JSON.
		parsed_settings = dict()

		try:
			for file_name in self.files:
				file_path = os.path.join(self.directory, file_name)
				with open(file_path, 'r') as file_handle:
					parsed_settings.update(json.load(file_handle))
		except json.JSONDecodeError as e:
			raise ImproperlyConfigured(
				'Your settings file(s) contain invalid JSON syntax! Please fix and restart!, {}'.format(str(e))
			)

		# Loop and set in local settings (+ uppercase keys).
		for key, value in parsed_settings.items():
			self.settings[key.upper()] = value 
Example 5
Project: python-libjuju   Author: juju   File: facade.py    (Apache License 2.0) View Source Project 6 votes vote down vote up
def from_json(cls, data):
        if isinstance(data, cls):
            return data
        if isinstance(data, str):
            try:
                data = json.loads(data)
            except json.JSONDecodeError:
                raise
        d = {}
        for k, v in (data or {}).items():
            d[cls._toPy.get(k, k)] = v

        try:
            return cls(**d)
        except TypeError:
            raise 
Example 6
Project: craton   Author: openstack   File: __init__.py    (license) View Source Project 6 votes vote down vote up
def assertJSON(self, response):
        if response.text:
            try:
                data = json.loads(response.text)
            except json.JSONDecodeError:
                self.fail("Response data is not JSON.")
            else:
                reference = "{formatted_data}\n".format(
                    formatted_data=json.dumps(
                        data, indent=2, sort_keys=True, separators=(',', ': ')
                    )
                )
                self.assertEqual(
                    reference,
                    response.text
                ) 
Example 7
Project: pheweb   Author: statgen   File: utils.py    (MIT License) View Source Project 6 votes vote down vote up
def get_phenolist():
    # TODO: should this be memoized?
    from .file_utils import common_filepaths
    filepath = common_filepaths['phenolist']
    try:
        with open(os.path.join(filepath)) as f:
            phenolist = json.load(f)
    except (FileNotFoundError, PermissionError):
        raise PheWebError(
            "You need a file to define your phenotypes at '{}'.\n".format(filepath) +
            "For more information on how to make one, see <https://github.com/statgen/pheweb#3-make-a-list-of-your-phenotypes>")
    except json.JSONDecodeError:
        print("Your file at '{}' contains invalid json.\n".format(filepath) +
              "The error it produced was:")
        raise
    for pheno in phenolist:
        pheno['phenocode'] = urllib.parse.quote_plus(pheno['phenocode'])
    return phenolist 
Example 8
Project: py_fake_server   Author: Telichkin   File: statistic.py    (MIT License) View Source Project 6 votes vote down vote up
def with_json(self, json_dict: dict) -> "Statistic":
        body = json.dumps(json_dict, sort_keys=True)

        actual_body = self.get_current_request().body.decode("utf-8", errors="skip")
        try:
            actual_json_dict = json.loads(actual_body)
        except json.JSONDecodeError:
            requested_time = self._current_request_index + 1
            self._error_messages.append(f"\nFor the {requested_time} time: with json {body}.\n"
                                        f"But for the {requested_time} time: json was corrupted "
                                        f"{actual_body.__repr__()}.")
            return self

        actual_body = json.dumps(actual_json_dict, sort_keys=True)
        if body != actual_body:
            requested_time = self._current_request_index + 1
            self._error_messages.append(f"\nFor the {requested_time} time: with json {body}.\n"
                                        f"But for the {requested_time} time: json was {actual_body}.")
        return self 
Example 9
Project: seproxer   Author: Rastii   File: handlers.py    (license) View Source Project 6 votes vote down vote up
def _load_stored_result_from_file(self, default=None):
        # First, let's attempt to load the existing results json file
        try:
            with open(self._results_file_path) as fp:
                file_data = fp.read()
        except IOError:
            return default

        # Now attempt to deserialize the file... if that fails, save a backup of the file
        try:
            return json.loads(file_data)
        except json.JSONDecodeError as e:
            backup_file_name = "corrupted.{}.{}".format(
                str(uuid.uuid4())[:8],
                self._results_file_name,
            )
            logger.error(
                "Unable to parse file {}: {}, renaming to {} and creating new file".format(
                    self._results_file_path, e, backup_file_name,
                )
            )
            dst = "{}/{}".format(self._results_directory, backup_file_name)
            os.rename(self._results_file_path, dst)

        return default 
Example 10
Project: sonic-py-swsssdk   Author: Azure   File: util.py    (license) View Source Project 6 votes vote down vote up
def setup_logging(config_file_path, log_level=logging.INFO):
    """
    Logging configuration helper.

    :param config_file_path: file path to logging configuration file.
    https://docs.python.org/3/library/logging.config.html#object-connections
    :param log_level: defaults to logging.INFO
    :return: None - access the logger by name as described in the config--or the "root" logger as a backup.
    """
    try:
        with open(config_file_path, 'rt') as f:
            config = json.load(f)
        logging.config.dictConfig(config)
    except (ValueError, IOError, OSError):
        # json.JSONDecodeError is throwable in Python3.5+ -- subclass of ValueError
        logging.basicConfig(log_level=log_level)
        logging.root.exception(
            "Could not load specified logging configuration '{}'. Verify the filepath exists and is compliant with: "
            "[https://docs.python.org/3/library/logging.config.html#object-connections]".format(config_file_path)) 
Example 11
Project: Examples   Author: hutomadotAI   File: conversation-redirect.py    (license) View Source Project 6 votes vote down vote up
def __init__(self, callResult):
        self.success = False
        try:
            # decode from json if possible
            result = callResult.json()
            # if there is a status then the response came from the API server
            if result['status']:
                # so store a copy of the json
                self.response = result
                # copy the json result code
                code = result['status']['code']
                # assemble a description of the result
                self.text = str(code) + ': ' + result['status']['info']
                # if we got a 200 OK then the the json object has the answer data
                if code == 200:
                    self.success = True
            else:
                # otherwise, assemble a description from the HTTP results
                self.text = 'Error ' + str(callResult.status_code) + ': ' + callResult.reason
        except JSONDecodeError:
            self.text = 'Error ' + str(callResult.status_code) + ': ' + callResult.reason


# chat API call 
Example 12
Project: Examples   Author: hutomadotAI   File: ChatSample.py    (license) View Source Project 6 votes vote down vote up
def __init__(self, callResult):
        self.success = False
        try:
            # decode from json if possible
            result = callResult.json()
            # if there is a status then the response came from the API server
            if result['status']:
                # so store a copy of the json
                self.response = result
                # copy the json result code
                code = result['status']['code']
                # assemble a description of the result
                self.text = str(code) + ': ' + result['status']['info']
                # if we got a 200 OK then the the json object has the answer data
                if code == 200:
                    self.success = True
            else:
                # otherwise, assemble a description from the HTTP results
                self.text = 'Error ' + str(callResult.status_code) + ': ' + callResult.reason
        except JSONDecodeError:
            self.text = 'Error ' + str(callResult.status_code) + ': ' + callResult.reason


# chat API call 
Example 13
Project: ava-website   Author: ava-project   File: forms.py    (license) View Source Project 6 votes vote down vote up
def get_manifest(self, archive):
        try:
            with ZipFile(archive.temporary_file_path()) as plugin:
                print(plugin.namelist())
                prefix = self.get_prefix(plugin)
                prefix = prefix + '/' if len(prefix) else ''
                with plugin.open('{}manifest.json'.format(prefix)) as myfile:
                    manifest = json.loads(myfile.read())
                validate_manifest(manifest)
                return manifest
        except BadZipFile:
            raise ValidationError('Bad .zip format')
        except FileNotFoundError:
            raise ValidationError('Error with upload, please try again')
        except KeyError:
            raise ValidationError('No manifest.json found in archive')
        except json.JSONDecodeError:
            raise ValidationError('Error with manifest.json, bad Json Format')
        except avasdk.exceptions.ValidationError as e:
            raise ValidationError('Error in manifest.json ({})'.format(e)) 
Example 14
Project: drydock   Author: att-comdev   File: base.py    (license) View Source Project 6 votes vote down vote up
def req_json(self, req):
        if req.content_length is None or req.content_length == 0:
            return None

        if req.content_type is not None and req.content_type.lower(
        ) == 'application/json':
            raw_body = req.stream.read(req.content_length or 0)

            if raw_body is None:
                return None

            try:
                json_body = json.loads(raw_body.decode('utf-8'))
                return json_body
            except json.JSONDecodeError as jex:
                print(
                    "Invalid JSON in request: \n%s" % raw_body.decode('utf-8'))
                self.error(
                    req.context,
                    "Invalid JSON in request: \n%s" % raw_body.decode('utf-8'))
                raise errors.InvalidFormat("%s: Invalid JSON in body: %s" %
                                           (req.path, jex))
        else:
            raise errors.InvalidFormat("Requires application/json payload") 
Example 15
Project: calm   Author: bagrat   File: handler.py    (license) View Source Project 6 votes vote down vote up
def _parse_and_update_body(self, handler_def):
        """Parses the request body to JSON."""
        if self.request.body:
            try:
                json_body = json.loads(self.request.body.decode('utf-8'))
            except json.JSONDecodeError:
                raise BadRequestError(
                    "Malformed request body. JSON is expected."
                )

            new_body = json_body
            if handler_def.consumes:
                try:
                    new_body = handler_def.consumes.from_json(json_body)
                except ValidationError:
                    # TODO: log warning or error
                    raise BadRequestError("Bad data structure.")

            self.request.body = new_body 
Example 16
Project: pyree-old   Author: DrLuke   File: worker.py    (license) View Source Project 6 votes vote down vote up
def parseMessage(self, msg):
        print(msg)
        try:
            decoded = json.loads(msg)
        except json.JSONDecodeError:
            return

        type = decoded["msgtype"]
        if type == "control":
            self.handleControl(decoded)
        elif type == "sheetdelta":
            self.passSheetDelta(decoded)
        elif type == "request":
            self.handleRequest(decoded)
        elif type == "nodedata":
            self.passNodedata(decoded) 
Example 17
Project: pyree-old   Author: DrLuke   File: workerManager.py    (license) View Source Project 6 votes vote down vote up
def discoverWorkers(self):
        """Discover new workers via udp broadcasts"""
        rlist, wlist, elist = select([self.discoverysocket], [], [], 0)
        if rlist:
            received = self.discoverysocket.recvfrom(4096)[0]
            discoverydata = {}
            try:
                discoverydata = json.loads(bytes.decode(received))
            except json.JSONDecodeError:
                pass

            if "ip" in discoverydata and "port" in discoverydata:
                if "host" in discoverydata:
                    name = discoverydata["host"]
                else:
                    name = discoverydata["ip"] + ":" + str(discoverydata["port"])
                if name not in self.workers:
                    treeItem = QTreeWidgetItem(1001)    # Type 1000 for Worker Item
                    treeItem.setText(0, name)
                    self.treeWidget.addTopLevelItem(treeItem)
                    self.grabPeriodicInfos()    # Grab monitor data
                    self.workers[name] = Worker(discoverydata, treeItem, nodeDataJar=self.nodeDataJar)
                    self.workers[name].tick(self.sheetDeltaMemory)
                    self.workers[name].synchronize() 
Example 18
Project: parsec-cloud   Author: Scille   File: backend.py    (license) View Source Project 6 votes vote down vote up
def _ws_recv_handler(self):
        # Given command responses and notifications are all send through the
        # same websocket, separate them here, passing command response thanks
        # to a Queue.
        while True:
            raw = await self._websocket.recv()
            try:
                if isinstance(raw, bytes):
                    raw = raw.decode()
                recv = ejson_loads(raw)
                if 'status' in recv:
                    # Message response
                    self._resp_queue.put_nowait(recv)
                else:
                    # Event
                    self._signal_ns.signal(recv['event']).send(recv['sender'])
            except (KeyError, TypeError, json.JSONDecodeError):
                # Dummy ???
                logger.warning('Backend server sent invalid message: %s' % raw) 
Example 19
Project: parsec-cloud   Author: Scille   File: session.py    (license) View Source Project 6 votes vote down vote up
def handshake(self):
        if self.id:
            raise HandshakeError('Handshake already done.')
        challenge = _generate_challenge()
        query = {'handshake': 'challenge', 'challenge': challenge}
        yield Effect(EHandshakeSend(ejson_dumps(query)))
        raw_resp = yield Effect(EHandshakeRecv())
        try:
            resp = ejson_loads(raw_resp)
        except (TypeError, json.JSONDecodeError):
            error = HandshakeError('Invalid challenge response format')
            yield Effect(EHandshakeSend(error.to_raw()))
            raise error
        resp = HandshakeAnswerSchema().load(resp)
        claimed_identity = resp['identity']
        try:
            pubkey = yield Effect(EPubKeyGet(claimed_identity))
            pubkey.verify(resp['answer'], challenge.encode())
            yield Effect(EHandshakeSend('{"status": "ok", "handshake": "done"}'))
            self.id = claimed_identity
        except (TypeError, PubKeyNotFound, InvalidSignature):
            error = HandshakeError('Invalid signature, challenge or identity')
            yield Effect(EHandshakeSend(error.to_raw()))
            raise error 
Example 20
Project: floto   Author: babbel   File: json_encoder.py    (license) View Source Project 6 votes vote down vote up
def load_string(json_string):
        """Deserialize `json_string` to Python Object. If `json_string` is not a valid json
        document, just return `json_string`. It is used in the context of activity results: floto
        handles str and JSON serialized results.

        Parameters
        ----------
        json_string : any

        Returns
        -------

        obj

        """
        try:
            j = json.loads(json_string)
        except (TypeError, json.JSONDecodeError):
            j = json_string
        return j 
Example 21
Project: ui2   Author: controversial   File: ui_io.py    (license) View Source Project 6 votes vote down vote up
def _json_get(inp):
    """ Get a Python object (list or dict) regardless of whether data is passed
    as a JSON string, a file path, or is already a python object.

    Returns the parsed data, as well as "native" if the data was already a
    Python object, "str" if the data was passed as a JSON string, or the path
    if the data passed was a file path """

    if not (isinstance(inp, dict) or isinstance(inp, list)):  # Python object
        try:                                                    # JSON string
            data = json.loads(inp)
            dataformat = "str"
        except json.JSONDecodeError:                            # JSON filepath
            # Store the filename in the dataformat variable if dataformat is a
            # file,  because it's just one fewer variable to keep track of
            dataformat = inp
            with open(inp, encoding="utf-8") as f:
                data = json.load(f)
    else:
        dataformat = "native"

    return data, dataformat 
Example 22
Project: loopchain   Author: theloopkr   File: rest_server.py    (license) View Source Project 6 votes vote down vote up
def post(self):
        request_body = json.dumps(request.get_json())
        channel = get_channel_name_from_json(request.get_json())
        query_data = json.loads('{}')
        try:
            # TODO Asnycronous call? ??? ???.
            response = ServerComponents().query(request_body, channel)
            logging.debug(f"query result : {response}")
            query_data['response_code'] = str(response.response_code)
            try:
                query_data['response'] = json.loads(response.response)

            except json.JSONDecodeError as e:
                logging.warning("your response is not json, your response(" + str(response.response) + ")")
                query_data['response'] = response.response

        except _Rendezvous as e:
            logging.error(f'Execute Query Error : {e}')
            if e.code() == grpc.StatusCode.DEADLINE_EXCEEDED:
                # TODO REST ?? ??? ???(?? ??? Response code ??) Extract Method ?? ?? ??? ?? ??? ??
                logging.debug("gRPC timeout !!!")
                query_data['response_code'] = str(message_code.Response.timeout_exceed)

        return query_data 
Example 23
Project: loopchain   Author: theloopkr   File: rest_server.py    (license) View Source Project 6 votes vote down vote up
def get(self):
        args = ServerComponents().parser.parse_args()
        response = ServerComponents().get_transaction(args['hash'], get_channel_name_from_args(args))
        tx_data = json.loads('{}')
        tx_data['response_code'] = str(response.response_code)
        tx_data['data'] = ""
        if len(response.data) is not 0:
            try:
                tx_data['data'] = json.loads(response.data)
            except json.JSONDecodeError as e:
                logging.warning("your data is not json, your data(" + str(response.data) + ")")
                tx_data['data'] = response.data

        tx_data['meta'] = ""
        if len(response.meta) is not 0:
            tx_data['meta'] = json.loads(response.meta)

        tx_data['more_info'] = response.more_info
        b64_sign = base64.b64encode(response.signature)
        tx_data['signature'] = b64_sign.decode()
        b64_public_key = base64.b64encode(response.public_key)
        tx_data['public_key'] = b64_public_key.decode()

        return tx_data 
Example 24
Project: loopchain   Author: theloopkr   File: rest_server.py    (license) View Source Project 6 votes vote down vote up
def get(self):
        logging.debug('transaction result')
        args = ServerComponents().parser.parse_args()
        logging.debug('tx_hash : ' + args['hash'])
        channel_name = get_channel_name_from_args(args)
        response = ServerComponents().get_invoke_result(args['hash'], channel_name)
        verify_result = dict()
        verify_result['response_code'] = str(response.response_code)
        if len(response.result) is not 0:
            try:
                result = json.loads(response.result)
                result['jsonrpc'] = '2.0'
                verify_result['response'] = result
            except json.JSONDecodeError as e:
                logging.warning("your data is not json, your data(" + str(response.data) + ")")
                verify_result['response_code'] = message_code.Response.fail
        else :
            verify_result['response_code'] = str(message_code.Response.fail)
        return verify_result 
Example 25
Project: fedoidc   Author: OpenIDC   File: bundle.py    (license) View Source Project 6 votes vote down vote up
def jwks_to_keyjar(jwks, iss=''):
    """
    Convert a JWKS to a KeyJar instance.

    :param jwks: String representation of a JWKS
    :return: A :py:class:`oic.utils.keyio.KeyJar` instance
    """
    if not isinstance(jwks, dict):
        try:
            jwks = json.loads(jwks)
        except json.JSONDecodeError:
            raise ValueError('No proper JSON')

    kj = KeyJar()
    kj.import_jwks(jwks, issuer=iss)
    return kj 
Example 26
Project: django-api-bouncer   Author: menecio   File: key_auth.py    (license) View Source Project 6 votes vote down vote up
def get_key_from_headers(self, request, key_names, key_in_body=False):
        if key_in_body:
            try:
                body = json.loads(request.body.decode('utf-8'))
                for k in key_names:
                    if k in body:
                        return body[k]
                return None
            except json.JSONDecodeError:
                return None

        for n in key_names:
            name = n.upper().replace('-', '_')
            key_name = 'HTTP_{0}'.format(name)
            if key_name in request.META:
                return request.META[key_name]

        return None 
Example 27
Project: Shallus-Bot   Author: cgropp   File: audio.py    (license) View Source Project 6 votes vote down vote up
def check_files():
    default = {"VOLUME": 50, "MAX_LENGTH": 3700, "VOTE_ENABLED": True,
               "MAX_CACHE": 0, "SOUNDCLOUD_CLIENT_ID": None,
               "TITLE_STATUS": True, "AVCONV": False, "VOTE_THRESHOLD": 50,
               "SERVERS": {}}
    settings_path = "data/audio/settings.json"

    if not os.path.isfile(settings_path):
        print("Creating default audio settings.json...")
        dataIO.save_json(settings_path, default)
    else:  # consistency check
        try:
            current = dataIO.load_json(settings_path)
        except JSONDecodeError:
            # settings.json keeps getting corrupted for unknown reasons. Let's
            # try to keep it from making the cog load fail.
            dataIO.save_json(settings_path, default)
            current = dataIO.load_json(settings_path)
        if current.keys() != default.keys():
            for key in default.keys():
                if key not in current.keys():
                    current[key] = default[key]
                    print(
                        "Adding " + str(key) + " field to audio settings.json")
            dataIO.save_json(settings_path, current) 
Example 28
Project: odooku   Author: odooku   File: channel.py    (license) View Source Project 6 votes vote down vote up
def listen(self, ws, environ):
        self._add(ws)
        while not ws.closed:
            try:
                message = ws.receive()
            except WebSocketError:
                break

            if message is not None:
                try:
                    message = json.loads(message)
                except json.JSONDecodeError:
                    break

                # Odoo heavily relies on httprequests, for each message
                # a new httprequest will be created. This request will be
                # based on the original environ from the socket initialization
                # request.
                httprequest = werkzeug.wrappers.Request(environ.copy())
                odoo.http.root.setup_session(httprequest)
                odoo.http.root.setup_db(httprequest)
                odoo.http.root.setup_lang(httprequest)
                gevent.spawn(self.respond, ws, httprequest, message)

        self._remove(ws) 
Example 29
Project: iCover   Author: littleneko   File: conf.py    (license) View Source Project 6 votes vote down vote up
def __get_conf_from_file(self, file_name):
        try:
            json_file = open(file_name, 'r')
            setting_dict = json.load(json_file)

            self.TRUST_P = setting_dict.get('trust_p', 0.45)
            self.COUNTRY = setting_dict.get('country', 'JP')
            self.COVER_MIN_SIZE = setting_dict.get('cover_min_size', 1000)
            self.SAVE_COVER_TYPE = setting_dict.get('save_cover_type', 1)
            self.DOWNLOAD_DIR = setting_dict.get('download_dir', './cover')
            self.SEARCH_POSTFIX_NAME = setting_dict.get('search_postfix_name', 'cue,m4a,flac')
            self.FILE_NAME_FORMAT = setting_dict.get('file_name_format', '')
            self.REPLACE_COVER = setting_dict.get('replace_cover', 1)
            self.SEARCH_THREAD_NUM = setting_dict.get('search_thread_num', 6)
            self.DOWNLOAD_THREAD_NUM = setting_dict.get('download_thread_num', 5)
        except FileNotFoundError:
            print("Conf file 'setting.json' not found")
            exit(1)
        except json.JSONDecodeError:
            print("Conf file err")
            exit(1)
        except Exception:
            print("Some err occur")
            exit(1) 
Example 30
Project: call_map   Author: nccgroup   File: project_settings_module.py    (license) View Source Project 6 votes vote down vote up
def load_from_persistent_storage(self):
        # precedence: files > (modules, scripts)

        # Note that `files` will only be changed manually
        # It is not updated by changing `modules` or `scripts`.
        # However, `files` will affect `modules` and `scripts`.

        decoded = {}
        if self.project_directory and self.project_directory.exists():
            for key, project_file in self.project_files.items():
                try:
                    decoded[key] = serialize.decode(category_type[key], json.loads(project_file.read_text()))
                except json.JSONDecodeError as err:
                    logger.error(err)
                except FileNotFoundError as err:
                    #logger.error(err)
                    pass

        return decoded 
Example 31
Project: deb-python-dcos   Author: openstack   File: common.py    (license) View Source Project 6 votes vote down vote up
def fetch_valid_json(cmd):
    """Assert stdout contains valid JSON

    :param cmd: program and arguments
    :type cmd: [str]
    :returns: parsed JSON AST
    """
    returncode, stdout, stderr = exec_command(cmd)

    assert returncode == 0
    assert stderr == b''
    try:
        return json.loads(stdout.decode('utf-8'))
    except json.JSONDecodeError:
        error_text = 'Command "{}" returned invalid JSON'.format(' '.join(cmd))
        raise Exception(error_text) 
Example 32
Project: autocert   Author: mozilla-it   File: cli.py    (license) View Source Project 6 votes vote down vote up
def do_request(ns):
    method = METHODS[ns.command]
    destinations = dictify(ns.destinations) if hasattr(ns, 'destinations') else None
    json = jsonify(ns, destinations=destinations if destinations else None)
    validate(ns.api_url, throw=True)
    response = requests.request(method, ns.api_url / 'autocert', json=json)
    status = response.status_code
    try:
        json = response.json()
        output(json)
    except JSONDecodeError as jde:
        print('status =', status)
        print('JSONDecodeError =', jde)
        print('text =', response.text)
        return -1
    return status 
Example 33
Project: keystore   Author: Spaxe   File: config_reader.py    (license) View Source Project 6 votes vote down vote up
def read(filepath):
  path = None

  try:
    if os.path.isfile(os.path.expanduser(filepath)):
      path = os.path.expanduser(filepath)
    elif os.path.isfile('./.keystorerc'):
      path = './.keystorerc'
    else:
      raise OSError('''The config file .keystorerc is not found in home or local working directory.

Please refer to https://pypi.python.org/pypi/keystore for setting up a .keystorerc file.''')

    with open(path) as f:
      conf = json.loads(f.read())
      return conf

  except OSError as err:
    print('Unable to open config: {}'.format(err), file=sys.stderr)
    return None

  except json.JSONDecodeError as err:
    print('Unable to parse config: {}'.format(err), file=sys.stderr)
    return None 
Example 34
Project: restcli   Author: dustinrohde   File: app.py    (license) View Source Project 6 votes vote down vote up
def show_response(self, response):
        """Print an HTTP Response."""
        if response.headers.get('Content-Type', None) == 'application/json':
            try:
                body = json.dumps(response.json(), indent=2)
            except json.JSONDecodeError:
                body = response.text
        else:
            body = response.text

        http_txt = self.HTTP_TPL.substitute(
            http_version=str(float(response.raw.version) / 10),
            status_code=response.status_code,
            reason=response.reason,
            headers=self.key_value_pairs(response.headers),
            body=body,
        )
        return highlight(http_txt, self.http_lexer, self.formatter) 
Example 35
Project: instabot.py   Author: instabot-py   File: instabot.py    (license) View Source Project 6 votes vote down vote up
def populate_user_blacklist(self):
        for user in self.user_blacklist:
            user_id_url = self.url_user_detail % (user)
            info = self.s.get(user_id_url)

            # prevent error if 'Account of user was deleted or link is invalid
            from json import JSONDecodeError
            try:
                all_data = json.loads(info.text)
            except JSONDecodeError as e:
                self.write_log('Account of user %s was deleted or link is '
                               'invalid' % (user))
            else:
                # prevent exception if user have no media
                id_user = all_data['user']['id']
                # Update the user_name with the user_id
                self.user_blacklist[user] = id_user
                log_string = "Blacklisted user %s added with ID: %s" % (user,
                                                                        id_user)
                self.write_log(log_string)
                time.sleep(5 * random.random()) 
Example 36
Project: jsoncut   Author: json-transformations   File: cli.py    (license) View Source Project 6 votes vote down vote up
def load_json(ctx, filename):
    if filename is None:
        if sys.stdin.isatty():
            click.echo(ctx.get_usage())
            click.echo("Try `jsoncut --help' for more information.")
            sys.exit(0)
        else:
            filename = '-'
    try:
        with click.open_file(filename) as file_:
            return json.load(file_)
    except EnvironmentError as e:
        if not sys.stdin.isatty():
            sys.stdin.read()
        click.echo(exc.default_error_mesg_fmt(e), err=True)
        sys.exit(1)
    except json.JSONDecodeError as e:
        click.echo(exc.default_error_mesg_fmt(e), err=True)
        sys.exit(1) 
Example 37
Project: SDV-Summary   Author: Sketchy502   File: database.py    (license) View Source Project 6 votes vote down vote up
def get_latest_log_entry_for(name,**kwargs):
	db = connect_db()
	c = db.cursor()
	refine_search = ''
	if 'successfully_uploaded' == True:
		refine_search = 'AND uploaded = 1 '
	c.execute('SELECT info_json, uploadable, uploaded FROM log WHERE name=? '+refine_search+'ORDER BY time DESC LIMIT 1',(name,))
	try:
		entry = c.fetchone()
		result = json.loads(entry[0])
		uploadable = entry[1]
		uploaded = entry[2]
	except (json.JSONDecodeError,TypeError):
		result = {}
		uploadable = None
		uploaded = None
	return result, uploadable, uploaded 
Example 38
Project: mosquito   Author: miti0   File: polo.py    (license) View Source Project 6 votes vote down vote up
def get_candles_df(self, currency_pair, epoch_start, epoch_end, period=False):
        """
        Returns candlestick chart data in pandas dataframe
        """
        try:
            data = self.get_candles(currency_pair, epoch_start, epoch_end, period)
            df = pd.DataFrame(data)
            df = df.tail(1)
            df['close'] = df['close'].astype(float)
            df['volume'] = df['volume'].astype(float)
            df['pair'] = currency_pair
            return df
        except (PoloniexError, JSONDecodeError) as e:
            print()
            print(colored('!!! Got exception while retrieving polo data:' + str(e) + ', pair: ' + currency_pair, 'red'))
        return pd.DataFrame() 
Example 39
Project: chrome_remote_interface_python   Author: wasiher   File: library.py    (license) View Source Project 6 votes vote down vote up
def recv(self):
        n = 0
        self._soc.settimeout(0.1)
        try:
            got = self._soc.recv()
            while 1:
                try:
                    val = json.loads(got)
                    self._handle_event(val['method'], val['params'])
                    n += 1
                    break
                except json.JSONDecodeError as e:
                    self._handle_event(got[:e.pos])
                    n += 1
                    got = got[e.pos:]
        except websocket.WebSocketTimeoutException:
            pass
        self._soc.settimeout(None)
        return n 
Example 40
Project: Slivka   Author: warownia1   File: task_queue.py    (license) View Source Project 6 votes vote down vote up
def read_json(conn, length):
        """
        Reads json request of the given length from the client socket.
        Specified length must be available in the socket; otherwise function
        will raise BlockingIOError.
        :param conn: active client socket to read data from
        :param length: length of the json content
        :return: dictionary corresponding to received json
        :rtype: dict
        :raise json.JSONDecodeError:
        :raise BlockingIOError:
        """
        buffer = io.BytesIO()
        while length > 0:
            chunk = conn.recv(min(2048, length))
            length -= buffer.write(chunk)
        content = buffer.getvalue().decode('utf-8')
        if not content:
            return None
        else:
            return json.loads(content) 
Example 41
Project: toshi-services-lib   Author: toshiapp   File: sofa.py    (license) View Source Project 6 votes vote down vote up
def parse_sofa_message(message):

    match = SOFA_REGEX.match(message)
    if not match:
        raise SyntaxError("Invalid SOFA message")
    body = match.group('json')
    try:
        body = json.loads(body)
    except json.JSONDecodeError:
        raise SyntaxError("Invalid SOFA message: body is not valid json")

    type = match.group('type').lower()
    if type not in VALID_SOFA_TYPES:
        raise SyntaxError("Invalid SOFA type")

    if type not in IMPLEMENTED_SOFA_TYPES:
        raise NotImplementedError("SOFA type '{}' has not been implemented yet".format(match.group('type')))

    try:
        return IMPLEMENTED_SOFA_TYPES[type](**body)
    except TypeError:
        raise SyntaxError("Invalid SOFA message: body contains unexpected fields") 
Example 42
Project: toshi-services-lib   Author: toshiapp   File: handlers.py    (license) View Source Project 6 votes vote down vote up
def __call__(self, request):

        if isinstance(request, (bytes, str)):
            try:
                request = json_decode(request)
            except json.JSONDecodeError:
                return _parse_error(request)

        # check batch request
        if isinstance(request, list):
            resp = []
            for r in request:
                result = await self._handle_single_request(r)
                if result:
                    resp.append(result)
            # if all were notifications
            if not resp:
                return None
            return resp
        # standard single request
        return await self._handle_single_request(request) 
Example 43
Project: qutils   Author: Raychee   File: models.py    (license) View Source Project 6 votes vote down vote up
def __init__(self, *args, **kwargs):
        super_self = super()
        super_self.__init__()
        super_self.__setattr__('__values__', {})
        if len(args) > 0:
            json_obj = args[0]
        else:
            json_obj = {}
        if isinstance(json_obj, str):
            try:
                json_obj = json.loads(json_obj)
            except json.JSONDecodeError:
                raise TypeError('json object is not valid (dict-like or json string) for conversion to model: {!r}'
                                .format(json_obj))
        self.from_dict(json_obj)
        self.from_dict(kwargs) 
Example 44
Project: foremast   Author: gogoair   File: lookups.py    (Apache License 2.0) View Source Project 5 votes vote down vote up
def json(self, branch='master', filename=''):
        """Retrieve _filename_ from GitLab.

        Args:
            branch (str): Git Branch to find file.
            filename (str): Name of file to retrieve.

        Returns:
            dict: Decoded JSON.

        Raises:
            SystemExit: Invalid JSON provided.

        """
        file_contents = self.get(branch=branch, filename=filename)

        try:
            json_dict = json.loads(file_contents)
        # TODO: Use json.JSONDecodeError when Python 3.4 has been deprecated
        except ValueError as error:
            msg = ('"{filename}" appears to be invalid json. '
                   'Please validate it with http://jsonlint.com. '
                   'JSON decoder error:\n'
                   '{error}').format(
                       filename=filename, error=error)
            raise SystemExit(msg)

        LOG.debug('JSON object:\n%s', json_dict)
        return json_dict 
Example 45
Project: scheduled-bots   Author: SuLab   File: bot_log_parser.py    (license) View Source Project 5 votes vote down vote up
def process_log(file_path):
    """
    Expects header as first line in log file. Header begins with comment character '#'. The line is a json string dump of
    a dictionary that contains the following keys:
    name: str, Task name
    maintainer: str, Name of person
    tags: list of tags associated with the task. can be empty
    properties: list of properties associated with the task. can be empty
    run_id: str, a run ID for the task run
    timestamp: str, timestamp for the task run

    :param file_path:
    :return:
    """
    # read header
    if isinstance(file_path, str):
        with open(file_path) as f:
            line = f.readline()
    else:
        line = file_path.readline()
    if not line.startswith("#"):
        raise ValueError("Expecting header in log file")
    try:
        metadata = json.loads(line[1:])
        if 'timestamp' in metadata:
            metadata['timestamp'] = dateutil_parse(metadata['timestamp'])
    except JSONDecodeError as e:
        metadata = {"name": "", "timestamp": "", "run_id": ""}

    df = parse_log(file_path)
    return df, metadata 
Example 46
Project: zinc   Author: PressLabs   File: models.py    (license) View Source Project 5 votes vote down vote up
def validate_json(value):
    try:
        json.loads(value)
    except json.JSONDecodeError:
        raise ValidationError("Not valid json") 
Example 47
Project: challenge-legi   Author: jshacks   File: views.py    (MIT License) View Source Project 5 votes vote down vote up
def submit(request):
    """Endpoint for submitting new crawls.
    Expects POST['data'] to be populated with data for a single document group."""

    # TODO authentication? Secret keys?
    # TODO stop processing the documents when submitted; use processing queues

    input_raw = request.POST.get('data')
    if not input_raw:
        return HttpResponseBadRequest('POST["data"] is not set!')
    try:
        input = json.loads(input_raw)
    except json.JSONDecodeError:
        return HttpResponseBadRequest('POST["data"] is not valid json')

    input_hash = hash.dict_sha1(input)

    submitted, created = models.SubmittedData.objects.update_or_create(
        sha1=input_hash,
        data=input
    )

    try:
        doc, new = process(submitted)
        index_data(doc)
    except ProcessingInputError as e:
        print(e)
        return HttpResponseServerError('error: ' + str(e))

    response = {
        'status': 'ok',
        'new': new,
    }

    return JsonResponse(response) 
Example 48
Project: sketal   Author: vk-brain   File: vk_api.py    (license) View Source Project 5 votes vote down vote up
def method(self, key, **data):
        """ Return a result of executing vk's method `method`

        Function for special cases only!
        This method doesn't process nor errors nor captcha.
        """

        url = f"https://api.vk.com/method/{key}?access_token={self.token}&v={VERSION}"

        if data is None:
            data = {}

        if data.get("_replace_nl", True):
            for k, v in data.items():
                data[k] = v.replace("\n", "<br>")

            if "_replace_nl" in data:
                del data["_replace_nl"]

        async with self.session.post(url, data=data, **self.req_kwargs) as resp:
            try:
                results = json_iter_parse(await resp.text())

                for data in results:
                    if 'response' in data:
                        return data['response']

            except json.JSONDecodeError:
                self.logger.error("Error while executing vk method: vk's response is wrong!")

                return False

        return False 
Example 49
Project: danmu-bilibili   Author: saberxxy   File: M_GetFans_Oracle.py    (license) View Source Project 5 votes vote down vote up
def _get_page(self, page_number):
        data = {
            'mid': str(self._mid),
            'page': str(page_number),
            '_': '1496132105785'
        }
        pages = 0
        fansnumber = 0
        fans_ids = ""
        try:
            url = "http://space.bilibili.com/ajax/friend/GetFansList?" + urlencode(data)
            response = requests.get(url)
            if response.status_code != 200:
                return None
            html_cont = response.text
            try:
                data = json.loads(html_cont)
                if data and (data.get('status') is True):
                    if data and 'data' in data.keys():
                        if(page_number == 1):
                            pages = data.get('data').get('pages')
                            fansnumber = data.get('data').get('results')
                        for fans in data.get('data').get('list'):
                            fans_ids = str(fans.get('fid')) + ',' + fans_ids
                elif (data.get('data') == "????????"):
                    pages = 0
                    fansnumber = 0
            except JSONDecodeError:
                pass
            self._fans_ids = fans_ids + self._fans_ids
            return pages, fansnumber
        except RequestException:
            return self._get_page(page_number) 
Example 50
Project: danmu-bilibili   Author: saberxxy   File: M_GetUserVideo_Oracle.py    (license) View Source Project 5 votes vote down vote up
def _getinfo(self, cont):
        aids = ""
        tag_ids = ""
        tag_names = ""
        tag_counts = ""
        try:
            data = json.loads(cont)
            if data and 'data' in data.keys():
                for video in data.get('data').get('vlist'):
                    aids = str(video.get('aid')) + ',' + aids
            return aids
        except JSONDecodeError:
            pass