def create_menu():

    _url = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid={}&secret={}"
    _rp = requests.get(_url.format(WECHAT.APPID, WECHAT.APPSECRET))
    access_token = loads(_rp.text)['access_token']

    url = "https://api.weixin.qq.com/cgi-bin/menu/create?access_token={}".format(access_token)
    response = requests.post(url, data=dumps(MENU_TEMPLE))

    return loads(response.text)['errmsg']

def translate(text, language):
    ## Choose random server from the server list.
    ## TODO: Make this less ugly :)
    result = json.loads(requests.get(config["etcd"]["connection_string"]+"language:{0}".format(language)).text)
    server = choice(json.loads(result["value"])["servers"])

    proxy = xmlrpc.client.ServerProxy(server)
    try:
        translation = proxy.translate({"text":text.lower()})
    except Exception as err:
        return err

    return json.dumps(translation)

 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 fetch(self, want="*"):
		if want == "*":
			req = "*"
		else:
			req = json.dumps(want)
		self.port.write(req)
		return json.loads(self.port.read())

def main():
    if not len(sys.argv) == 2:
        print 'Requires a couple of arguments'
        return -1

    since = time.strftime('%Y-%m-%d', time.localtime())
    qs = urllib.urlencode({'q' : sys.argv[1], 'since' : since})

    url_fd = urllib2.urlopen('%s?%s' % (SEARCH_URL, qs))
    body  = url_fd.read()

    if not body:
        print 'Empty body?'
        return -1

    data = yajl.loads(body)
    if not data.get('results'):
        return 0

    for r in data.get('results', []):
        from_user = r.get('from_user', '').lower()
        if not from_user:
            continue

        if from_user == 'jenkinsci':
            continue

        retweets = r.get('metadata', {}).get('recent_retweets', 0)

        print '%s : %s \n\t%s' % (from_user, retweets, r.get('text'))

    return 0

 def testLong(self):
     ''' http://github.com/rtyler/py-yajl/issues#issue/10 '''
     if is_python3():
         return
     data = {long(1) : 2}
     result = yajl.loads(yajl.dumps(data))
     self.assertEquals({'1': 2}, result)

 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 down_playlist():
    pl_url = "http://douban.fm/j/mine/playlist?type=n&h=|432599:p&channel=1&from=mainsite&r=ecc38a4d94"
    pl_f = urllib2.urlopen(pl_url)
    data = pl_f.read()
    pl = yajl.loads(data)
    pl_f.close()
    return pl['song']

    def runTest(self):
        dumpable = [11889582081]

        rc = yajl.dumps(dumpable)
        self.assertEquals(rc, '[11889582081]')
        rc = yajl.loads(rc)
        self.assertEquals(rc, dumpable)

 def add_new_data(self,session_info,new_data,old_ack_id):
     new_data=json.loads(new_data)
     #print new_data
     user_status=self.get_secure_cookie(session_info['session_id'])
     if(not user_status or not (user_status=='admin') or not old_ack_id):
         self.finish({'error':"You cannot sir !"})
         return
     old_ack_id=int(old_ack_id)
     user_stream_data=None
     
     if(new_data.get('pic_state')):
         session_info['start_from']=old_ack_id+1 ##one change done jus now , so add one
         session_info['pic_state']=new_data['pic_state']
         session_info['data']=[]
         user_stream_data={'data':[],'pic_state':new_data['pic_state']}
     else:    
         session_info['data'].append(new_data['data'])
         user_stream_data={'data':[new_data['data']]}
         
     ack_id=session_info['start_from']+len(session_info['data'])
     user_stream_data['ack_id']=ack_id
     
     for i in session_info['connections'].keys():
         i.finish(user_stream_data)
         del session_info['connections'][i]                
     
     self.finish({'ack_id':ack_id}) # to admin

 def add_gadm1_codes_to_gadm1_json(self):
     """
     Add GADM level 1 information to level 1 map outlines from GADM.
     """
     with open('../static/topojson/gadm1_map.json') as f:
         ga = json.loads(f.read())
     ga['objects']['regions'] = ga['objects']['_bejeezus']
     ga['objects'].pop('_bejeezus', None)
     for region in ga['objects']['regions']['geometries']:
         props = region['properties']
         try:
             region['properties']['iso'] = region['properties']['ISO']
             region['properties']['adm1'] = '{0:02d}'.format(region['properties']['ID_1'])
             region['properties']['adm0'] = '{0}'.format(region['properties']['ID_0'])
             region['properties']['adm'] = '{0}{1:02d}'.format(region['properties']['ID_0'], region['properties']['ID_1'])
             region['properties']['name'] = region['properties']['NAME_1']
             region['properties']['country'] = region['properties']['NAME']
             region['properties'].pop('ISO', None)
             region['properties'].pop('ID_1', None)
             region['properties'].pop('ID_0', None)
             region['properties'].pop('ENGTYPE_1', None)
             region['properties'].pop('TYPE_1', None)
             region['properties'].pop('NL_NAME_1', None)
             region['properties'].pop('VARNAME_1', None)
         except:
             pass
     with open('../static/topojson/atlas_gadm1.json', 'w') as f:
         f.write(json.dumps(ga))
     return ga

    def test_chinese(self):
        ''' Testing with simplified chinese for http://github.com/rtyler/py-yajl/issues/#issue/7 '''
        char = '\u65e9\u5b89, \u7238\u7238'
        if not is_python3():
            from tests import python2
            char = python2.IssueSevenTest_chinese_char
        out = yajl.dumps(char).lower()
        self.assertEquals(out, '"\\u65e9\\u5b89, \\u7238\\u7238"')

        out = yajl.dumps(out).lower()
        self.assertEquals(out, '"\\"\\\\u65e9\\\\u5b89, \\\\u7238\\\\u7238\\""')

        out = yajl.loads(out)
        self.assertEquals(out, '"\\u65e9\\u5b89, \\u7238\\u7238"')

        out = yajl.loads(out)
        self.assertEquals(out, char)

def add_test(v):
    #  These modules have a few round-tripping problems...
    try:
        assert cjson.decode(cjson.encode(v)) == v
        assert yajl.loads(yajl.dumps(v)) == v
    except Exception:
        pass
    else:
        TESTS.append((v,tnetstring.dumps(v),cjson.encode(v)))

 def decode_json(self, decode=None, **kwargs):
     if not decode:
         return {}
     piece = decode.split('/')[-1]
     entry = self.redis[piece]
     if not entry:
         return {}
     entry = json.loads(entry)
     return {'url' : entry['url'], 'encoded' : 'http://urlenco.de/%s' % piece}

 def trim_aggr_data(self, var):
     """
     Trim extra scenarios and irrigations from json file (for initial
     loading of page).
     """
     with open('../static/json/aggr/{}_gadm{}.json'.format(var, self._adm), 'r') as f:
         data = json.loads(f.read())
     data['data'] = {k: np.array(v)[:, 0, 0].tolist() for k, v in data['data'].iteritems()}
     with open('../static/json/aggr/{}_gadm{}_home.json'.format(var, self._adm), 'w') as f:
         f.write(json.dumps(data))

def consumetag(message, tag):
    try:
        messg = simplejson.loads(message)
        cmd = "%s%s" % (messg, tag)
        result = eval(cmd)
        return str(result)
    except KeyError:
        return ''
    except TypeError:
        return ''

def getValueForItemFromJson(response, item_name):
    try:
        string_name = response.text
        strDecoded = string_name.decode().encode('utf-8')
        json = simplejson.loads(strDecoded)
        value = json[item_name]
        return value, 'ok'
    except:
        print 'Unable to getValueForItemFromJson: %s, %s' % (item_name, response)
        return response, 'error'

 def fetch_state(self, uuid):
     if uuid not in self.telescreens:
         return (uuid, None)
     port = self.telescreens[uuid]
     port.write("S")
     res = port.read()
     if res:
         return (uuid, json.loads(res))
     else:
         del self.telescreens[uuid]
         return (uuid, None)

    def test_latin1(self):
        ''' Testing with latin-1 for http://github.com/rtyler/py-yajl/issues/#issue/7 '''
        char = 'f\xe9in'
        if not is_python3():
            from tests import python2
            char = python2.IssueSevenTest_latin1_char
        # The `json` module uses "0123456789abcdef" for its code points
        # while the yajl library uses "0123456789ABCDEF", lower()'ing
        # to make sure the resulting strings match
        out = yajl.dumps(char).lower()
        self.assertEquals(out, '"f\\u00e9in"')

        out = yajl.dumps(out).lower()
        self.assertEquals(out, '"\\"f\\\\u00e9in\\""')

        out = yajl.loads(out)
        self.assertEquals(out, '"f\\u00e9in"')

        out = yajl.loads(out)
        self.assertEquals(out, char)

def zhihu_to_dump():
    with open('/home/zuroc/zpage/misc/spider/zhihu_question_to_dump.json') as zhihu_question_dump:
        for line in reversed(list(zhihu_question_dump)):
            line = loads(line)
            key = line[1]
            filename = md5(key).hexdigest()
            #print filename
            path = '/tmp/www.zhihu.com/%s'%filename
            if exists(path):
                r = line_parser(path, line)
            else:
                r = None
            if not r:
                yield line[-2], line[2], line[-1]