Python yajl.dumps函数代码示例

 def post(self,game_session):
     self.game_session=game_session
     game=sessions[game_session]        
     uid=self.get_secure_cookie("uid")
     try:
         index=json.loads(self.get_argument("i",None))
     except:
         self.finish()            
         return
     if(not index):
         if(not game["users"][uid]):
             game["user_connections"][uid]=self
             return            
         self.finish({"updates":game["users"][uid]+["reconnect"]})
         game["users"][uid]=[]
         return
     
     if(game["current_uid"]!=uid): #ok update game state and send the status update for the other user and keep this user in wait mode
         if(game["state"][index[0]][index[1]]!=False):
             self.finish({"updates":["your move"]})
             return
         game["state"][index[0]][index[1]]=uid
         uid_other=game["current_uid"]
         game["user_connections"][uid]=self
         game["current_uid"]=uid
         try:               
             game["user_connections"][uid_other].finish({'updates':["update "+json.dumps(index),"your move"]})
         except:
             game["users"][uid_other]+=["update "+json.dumps(index),"your move"]
         self.finish({"updates":["wait","reconnect"]})
         return
     self.finish({"updates":["wait"]})

 def magpie_to_json(self, var):
     """
     One-time use. For converting MAgPIE nc4 to json.
     """
     # for crop in ['bmg', 'bmt', 'cas', 'mai', 'mgr', 'mil', 'nut', 'oth', 'pea', 'rap', 'ric', 'sgb', 'soy', 'sug', 'sun', 'whe']:
     for crop in ['whe',]:
         d = netCDF4.Dataset(os.path.join(
             '..', 'data', 'netcdf', 'magpie',
             'MAgPIE_LUC_for_ATLAS_illustration_{}_agg.nc4'.format(crop)
         ))
         # for irr in ['firr', 'rainf']:
         #     d = netCDF4.Dataset(os.path.join('..', 'data', 'netcdf', 'magpie', 'MAgPIE_LUC_for_ATLAS_illustration_{}_{}.nc4'.format(crop, irr)))
         _v = d.variables['{}_gadm{}'.format(crop, self._adm)][:]
         _gi = d.variables['gadm{}_index'.format(self._adm)][:]
         new_data = {}
         for i in range(len(_gi)):
             new_data[str(_gi[i])] = [v - np.mean(_v[:20]) for v in _v[i].tolist()[20:]]
         with open('../static/json/aggr/gadm{}/magpie/{}_gadm{}.json'.format(
                 self._adm, crop, self._adm), 'w') as f:
             f.write(
                 json.dumps(
                     {
                         'data': new_data,
                         'min': round(np.min(_v[:]), 1),
                         'max': round(np.max(_v[:]), 1),
                     }
                 )
             )
         trimmed = {
             'data': {k: np.array(v)[:, 0].tolist() for k, v in new_data.iteritems()},
             'min': round(np.min([np.array(v)[:, 0].tolist() for k, v in new_data.iteritems()]), 1),
             'max': round(np.max([np.array(v)[:, 0].tolist() for k, v in new_data.iteritems()]), 1),
         }
         with open('../static/json/aggr/gadm{}/magpie/{}_gadm{}_home.json'.format(self._adm, crop, self._adm), 'w') as f:
             f.write(json.dumps(trimmed))

    def runTest(self):
        normal = {'a' : 'b', 'c' : 'd'}
        self.assertEquals(yajl.dumps(normal), '{"a":"b","c":"d"}')

        if not is_python3():
            from tests import python2
            self.assertEquals(yajl.dumps(python2.IssueTwelveTest_dict), '{"a":"b","c":"d"}')

 def api(self, **kwargs):
     self.content_type = 'text/plain'
     return '{}'
     if kwargs.get('encode'):
         return json.dumps(self.encode_json(**kwargs))
     if kwargs.get('decode'):
         return json.dumps(self.decode_json(**kwargs))
     return '{}'

def report_result(item):
    try:
        item_json = json.dumps(item)
    except UnicodeDecodeError:
        item['result'] = "FIXME: unicode decode error"
        item.pop('content')
        try:
            item_json = json.dumps(item)
        except UnicodeDecodeError:
            log.error("Fatal unicode decode error @ %s", item['url'])
            return
    request_manager('/report', 'PUT', item_json)

 def insert(title, tags, content, author, rating, url, reply_list, pic_list):
     key = url_key_builder(url)
     if not Spider.get(url_hash=key):
         entry = Spider()
         entry.title = title
         entry.tags = dumps(tags)
         entry.content = content
         entry.author = author
         entry.rating = rating
         entry.url_hash = key
         entry.url = url
         entry.url_hash = key
         entry.reply_list = dumps(reply_list)
         entry.pic_list = dumps(pic_list)
         entry.save()

 def collect(self, port):
     while True:
         req = port.read()
         if not req:
             break
         if req == "?":
             self.ggroup.map(self.pingall, self.telescreens.iterkeys())
             port.write(json.dumps(self.telescreens.keys()))
             continue
         if req == "*":
             want_list = self.telescreens.iterkeys()
         else:
             want_list = json.loads(req)
         rep = self.ggroup.map(self.fetch_state, want_list)
         port.write(json.dumps({k: v for k, v in rep if v}))

    def _call(self, func_name, o): 
        if func_name.startswith("_") or func_name in self.DISABLED:
            raise HTTPError(400)

        func = getattr(self,func_name, None)
        if func is None:
            raise HTTPError(501)

        if o is not None:

            o = loads(o)
            type_o = type(o)

            if type_o is list:
                r = func(*o)
            elif type_o is dict:
                r = func(**o) 
            else:
                r = func(o)
        else:
            r = func()
        if r is None:
            chunk = '{}'
        elif isinstance(r, Err) and r: 
            chunk = '{"err":%s}'%str(r)
        elif isinstance(r, JsOb): 
            chunk = str(r)
        else:
            chunk = dumps(r)
        return chunk

 def add_gadm1_codes_to_ne1_json(self):
     """
     Add GADM level 1 information to level 1 map outlines from Natural Earth.
     """
     gadm = pd.DataFrame.from_csv('./gadm1.meta.csv', index_col=4)
     gadm.index = np.arange(len(gadm))
     with open('../static/topojson/ne1_s0001.json') as f:
         ne = json.loads(f.read())
     for region in ne['objects']['regions']['geometries']:
         props = region['properties']
         try:
             country = pycountry.countries.get(alpha2=props['iso_a2'])
             region['properties']['iso'] = country.alpha3
             id0 = gadm.ix[gadm['ISO'] == country.alpha3].\
                 ix[gadm['NAME'] == props['name'].encode('latin_1')].ID_0.values[0]
             id1 = gadm.ix[gadm['ISO'] == country.alpha3].\
                 ix[gadm['NAME'] == props['name'].encode('latin_1')].ID_1.values[0]
             region['properties']['adm1'] = '{0:02d}'.format(id1)
             region['properties']['adm0'] = '{0}'.format(id0)
             region['properties']['adm'] = '{0}{1:02d}'.format(id0, id1)
         except:
             pass
     with open('../static/topojson/atlas_gadm1.json', 'w') as f:
         f.write(json.dumps(ne))
     return ne

def server(request):
    handler_map = urls.get(request.path)
    if not handler_map:
        # default behaviour is 404 to all unknown URLs
        raise webob.exc.HTTPNotFound()

    auth_error = check_auth(request)
    if auth_error:
        log.info("auth: " + auth_error)
        raise webob.exc.HTTPUnauthorized(auth_error)

    with manager_pool.item() as manager:
        handler = method_dispatcher(**dict( (method, getattr(manager, name))
                                            for method,name in handler_map.iteritems() ))
        result = handler(request)

    response = Response(json.dumps(result), content_type='application/json')
    if not response.etag and (200 <= response.status_int < 300):
        # generate Etag from URL and response.body
        sha256_tag = hashlib.sha256(request.path + response.body).digest()
        response.etag = b64encode(sha256_tag)
    if 'gzip' in request.accept_encoding and len(response.body) > MIN_COMPRESS_LENGTH:
        # client supports gzipped answer and response is reasonably long for compression benefits
        response.content_encoding = 'gzip'
        response.body = gzip_string(response.body)
    return response

def DeleteAllDatasetsFromOrg(organization, hdx_site, apikey, verbose=True):
  '''Delete all datasets owned by an organization.'''

  if verbose:
    print "--------------------------------------------------"
    print "//////////////////////////////////////////////////"
    print "--------------------------------------------------"
    print "////////////// DELETING DATASETS /////////////////"
    print "--------------------------------------------------"
    print "//////////////////////////////////////////////////"
    print "--------------------------------------------------"

  # Checking for input.
  if (organization is None):
    print "No organization id provided. Please provide an organization id."
    print "--------------------------------------------------"
    return False

  # Base config.
  organization_show_url = hdx_site + '/api/action/organization_show?id='
  package_delete_url = hdx_site + '/api/action/package_delete'
  headers = { 'X-CKAN-API-Key': apikey, 'content-type': 'application/json' }

  # Fetching dataset information.
  dataset_dict = requests.get(organization_show_url + organization, headers=headers, auth=('dataproject', 'humdata')).json()



  #
  # Progress bar.
  #
  i = 0
  widgets = [I('prompt_bullet'), ' Deleting resources:', pb.Percentage(), ' ', pb.Bar('-'), ' ', pb.ETA(), ' ']

  pbar = pb.ProgressBar(widgets=widgets, maxval=len(dataset_dict)).start()

  #
  # Iterating over every dataset.
  #
  if dataset_dict["success"] is True:

    pbar.update(i)

    for dataset in dataset_dict["result"]["packages"]:

      u = { 'id': dataset["id"] }
      r = requests.post(package_delete_url, data=json.dumps(u), headers=headers, auth=('dataproject', 'humdata'))

      if r.status_code != 200:
        print "%s : %s" % (I('prompt_error'), dataset["name"])

      else:
        print "%s : %s" % (I('prompt_success'), dataset["name"])

    i += 1

  else:
    print "%s There was an error getting the dataset list." % I('prompt_error')
    print "--------------------------------------------------"
    return False

	def fetch(self, want="*"):
		if want == "*":
			req = "*"
		else:
			req = json.dumps(want)
		self.port.write(req)
		return json.loads(self.port.read())

    def get(self, id):
#        data = {
#            "zsite":{
#                "name":"w",
#                "unit":"xx",
#                "title":"zz"
#            },
#            "name":"2011年第2次BPUG活动",
#            "id":1234,
#            "fav":True,
#            "reply_count":1,
#            "tag_id":232,
#            "tag_name":"sss"
#        }
        po = Po.mc_get(id)
        user = po.user
        result = [id]
        result.extend(feed_tuple_by_db(id))
        result.pop()
        result.pop()
        result.append(po.htm)

        zsite = [user.name, user.link]
        zsite.extend(career_current(po.user_id))

        result.append(zsite)
        self.finish(dumps(result))

    def post(self):
        result = None
        current_user_id = self.current_user_id
        txt = self.get_argument('txt', None)
        if txt:
            host = self.request.host
            zsite = zsite_by_domain(host)
            if zsite and zsite.cid == CID_SITE:
                zsite_id = zsite.id
            else:
                zsite_id = 0

            m = po_word_new(current_user_id, txt, zsite_id=zsite_id)
            if not zsite_id and m:
                c_dict = career_dict(set([current_user_id]))
                unit, title = c_dict[current_user_id]
                result = [
                    [
                        1, zsite.name, zsite.link, unit,
                        title, pic_url_with_default(current_user_id, '219'),
                        [[m.id, [], 0, 61, 0, 0, 0, time.time(), None, txt_withlink(txt), False]]
                    ],
                    []
                ]
        self.finish(dumps(result))

def charged(out_trade_no, total_fee, rid, d):
    id, vid, ck = out_trade_no.split('_', 2)
    user_id, vcid = verifyed(vid, ck)
    if vcid == CID_VERIFY_MONEY:
        t = Trade.get(id)
        if t and t.to_id == user_id and t.rid == rid  and t.value + t.tax == int(float(total_fee)*100):
            if t.state == TRADE_STATE_ONWAY:
                trade_finish(t)
                trade_log.set(id, dumps(d))
                for_t = Trade.get(t.for_id)
                if for_t:
                    if bank_can_pay(for_t.from_id, for_t.value):
                        for_cid = for_t.cid
                        if for_cid == CID_TRADE_PAY:
                            trade_finish(for_t)
                            pay_notice(for_t.id)
                        elif for_cid == CID_TRADE_EVENT:
                            from event import event_joiner_state, event_joiner_new, EVENT_JOIN_STATE_NEW
                            event_id = for_t.rid
                            user_id = for_t.from_id
                            if event_joiner_state(event_id, user_id) < EVENT_JOIN_STATE_NEW:
                                trade_open(for_t)
                                event_joiner_new(event_id, user_id)
                            else:
                                trade_fail(for_t)
                                return t
                        return for_t
            return t