Python ujson 模块，decode() 实例源码

def get_json_loads():
    global _json_loads, _json_module_name
    if _json_loads is None:
        # Timings reported for a fragment file with 37177 lines
        # (35634 "RECORD" and 1534 "IGNORE" records.)
        try:
            # 40.05 seconds
            import ujson
            _json_loads = ujson.decode
            _json_module_name = "ujson"
        except ImportError:
            try:
                # 41.85 seconds
                import cjson
                _json_loads = cjson.decode
                _json_module_name = "cjson"
            except ImportError:
                # 55.5 seconds
                _json_loads = json.loads
                _json_module_name = "json"

    return _json_loads

def updates(callback):
    """
    This function takes the callback as an input and creates an instance for each message received and stores
    it(instance) into an array. Which is then returned

    :param callback: contains the callback from facebook.
    :return: array of Message instances.

    """
    entries = []
    try:
        callback = json.decode(callback)
    except:
        pass
    for entry in callback["entry"]:
        messaging = entry["messaging"]
        messages = [Message(data) for data in messaging]
        entries.extend(messages)
    return entries

def request(self, headers, payload, args, url):
        while True:
            proxy = self.proxyProvider.pick()
            try:
                response = requests.request(
                    "POST", url, data=payload, headers=headers,
                    proxies={"https": proxy.url},
                    timeout=5,verify=False
                )

                with self.lock:
                    with sqlite3.connect(self.db_name) as c:
                        try:
                            print(response.text)
                            decoded = ujson.decode(response.text)["object"]
                            self.done += 1
                            for x in decoded:
                                c.execute("INSERT INTO mobike VALUES (%d,"%s",%d,%d,%s,%s,%f,%f)" % (
                                    int(time.time()) * 1000, x["bikeIds"], int(x["biketype"]), int(x["distId"]),
                                    x["distNum"], x["type"], x["distX"],
                                    x["distY"]))

                            timespend = datetime.datetime.now() - self.start_time
                            percent = self.done / self.total
                            total = timespend / percent
                            print(args, self.done, percent * 100, self.done / timespend.total_seconds() * 60, total,
                                  total - timespend)
                        except Exception as ex:
                            print(ex)
                    break
            except Exception as ex:
                proxy.fatal_error()

def form(self):
        result = {}

        if self.request_content_length and self.request_content_type == 'application/json':
            fp = self.environ['wsgi.input']
            data = fp.read(self.request_content_length)
            return ujson.decode(data)

        try:
            storage = cgi.FieldStorage(
                fp=self.environ['wsgi.input'],
                environ=self.environ,
                strict_parsing=False,
                keep_blank_values=True
            )
        except TypeError:
            raise exceptions.HttpBadRequest('Cannot parse the request.')

        if storage.list is None or not len(storage.list):
            return result

        def get_value(f):
            # noinspection PyProtectedMember
            return f.value if isinstance(f,  cgi.MiniFieldStorage) \
                              or (isinstance(f, cgi.FieldStorage) and not f._binary_file) else f

        for k in storage:
            v = storage[k]

            if isinstance(v, list):
                result[k] = [get_value(i) for i in v]
            else:
                result[k] = get_value(v)

        return result

def user_insert(self, member, data):
        """Create a new user entry with the given data"""
        jd = self.dump({member.guild.id: data})
        req = f"""INSERT INTO userdata (UUID, info) VALUES ({member.id}, '{jd}')"""
        async with self._conn.acquire() as connection:
            response = await connection.fetchval(req)
            return json.decode(response) if response else response

def user_select(self, member):
        """Select a user's data for a specified server"""
        req = f"""SELECT info -> '{member.guild.id}' FROM userdata WHERE UUID = {member.id}"""
        async with self._conn.acquire() as connection:
            response = await connection.fetchval(req)
        return json.decode(response) if response else response

def user_full_select(self, member):
        """Select a user's data for a specified server"""
        req = f"""SELECT info FROM userdata WHERE UUID = {member.id}"""
        async with self._conn.acquire() as connection:
            response = await connection.fetchval(req)
        return json.decode(response) if response else response

def user_update(self, member, data):
        """Update a user's data for a specific server"""
        jd = self.dump(data)
        req = f"""UPDATE userdata
        SET info = '{jd}'
        WHERE UUID = {member.id}"""
        async with self._conn.acquire() as connection:
            response = await connection.fetchval(req)
        return json.decode(response) if response else response

def get_all_user_data(self, member):
        """Get a user's data for all servers"""
        req = f"""SELECT info FROM userdata WHERE UUID = {member.id}"""
        async with self._conn.acquire() as connection:
            response = await connection.fetchval(req)
        return json.decode(response) if response else response

    # Server functions
    ########################################################################

def guild_select(self, guild):
        """Get a guild from the db"""
        req = f"""SELECT info FROM servdata WHERE UUID = {guild.id}"""
        async with self._conn.acquire() as connection:
            response = await connection.fetchval(req)
        return json.decode(response) if response else response

def guild_update(self, guild, data):
        """Update a guild"""
        jd = self.dump(data)
        req = f"""UPDATE servdata
        SET info = '{jd}'
        WHERE UUID = {guild.id}"""
        async with self._conn.acquire() as connection:
            response = await connection.fetchval(req)
        return json.decode(response) if response else response

def get_box(self, member):
        """Get user's Pokemon box"""
        ub = await self.db.user_item(member, "box")
        return [Pokemon(*x) for x in json.decode(ub)]

def get_inventory(self, member):
        """Get user's inventory"""
        ui = await self.db.user_item(member, "items")
        return json.decode(ui)

def get_user_info(self, user_id):
        """

        The User Profile API lets your bot get more information about the user
        for more info go to https://developers.facebook.com/docs/messenger-platform/user-profile

        :param user_id: User id of the person of whom user info is to be retrieved.
        :type user_id: str
        :return: first name,last name,profile pic,locale,timezone,gender.

        """
        url = self.URL.format(user_id)
        key = {"fields": "first_name,last_name,profile_pic,locale,timezone,gender",
               "access_token": self.Access_Token
               }
        response = requests.get(url, params=key)
        data = response.json()
        try:
            data = json.decode(data)
        except:
            pass
        try:
            return data["first_name"], data["last_name"], data["profile_pic"], data["locale"], data["timezone"], data[
                "gender"]
        except:
            return None