def dial():
    try:
        From = request.args['From']
        CallUUID = request.args['CallUUID']
        redis.set(From, CallUUID)
    except KeyError:
        From = None
        CallUUID = None

    r = plivo.Response()
    speak_parameters = {
            'language':'en-US',
            'loop':'1',
            'voice':'WOMAN',
            }

    r.addSpeak('Welcome to Plivo demo test.', **speak_parameters)
    play_parameters = {
            'loop':'50',
            }
    r.addPlay('http://s3.amazonaws.com/plivocloud/music.mp3', **play_parameters)

    response = make_response(r.to_xml())
    response.headers['Content-Type'] = 'text/xml'
    return response

def route_post_ad(slot):
    if not advertiser_id():
        return '', 404

    asset = request.files['asset']

    id = next_ad_id()
    key = ad_key(slot, id)
    type = fetch(request.form, 'type')
    if not type:
        type = asset.mimetype
    if not type:
        type = 'video/mp4'

    redis = get_redis()
    redis.hmset(key, {
        'slot': slot,
        'id': id,
        'title': fetch(request.form, 'title'),
        'type': type,
        'advertiser': advertiser_id(),
        'destination': fetch(request.form, 'destination'),
        'impressions': 0
        })

    redis.set(asset_key(slot, id), asset.read())
    redis.rpush(slot_key(slot), id)
    redis.sadd(advertiser_key(advertiser_id()), key)

    return jsonify(get_ad(slot, id))

 def create(cls, data, listeners):
     if not 'id' in data:
         data['id'] = redis.incr('global:%s' % cls._namespace())
     _id = cls._id(data['id'])
     redis.set(_id, data)
     redis.lpush(cls._namespace(), _id)
     return data, listeners

    def xaui_unpack(self, bram_dmp, hdr_index, pkt_len, skip_indices, redis):
        pkt_64bit_hdr = struct.unpack(
            "Q",
            bram_dmp["msb_data"][(4 * hdr_index) : (4 * hdr_index) + 4]
            + bram_dmp["lsb_data"][(4 * hdr_index) : (4 * hdr_index + 4)],
        )[0]
        pkt_mcnt = pkt_64bit_hdr >> 16
        pkt_ant = pkt_64bit_hdr & 0xFFFF
        pkt_freq = pkt_mcnt % 2048  # mcnt % nchans
        raw_xaui_data = ""
        for pkt_index in range(1, (pkt_len)):
            abs_index = hdr_index + pkt_index
            if skip_indices.count(abs_index) > 0:
                continue

            raw_xaui_data += (
                bram_dmp["msb_data"][(4 * abs_index) : (4 * abs_index) + 4]
                + bram_dmp["lsb_data"][(4 * abs_index) : (4 * abs_index) + 4]
            )
            if len(raw_xaui_data) == 256:
                print "writing Ant%d, Chan%d into redis." % (pkt_ant, pkt_freq)
                try:
                    redis.set("px%d:snap_xaui_raw:%d:%d" % (self.xeng[0] + 1, pkt_ant % 4, pkt_freq), raw_xaui_data)
                except Exception, e:
                    print "REDIS ERROR(xaui unpack)", e

def save_model(model, redis):
    json_string = model.to_json()
    redis.set("{}_model".format(datetime.date.today()), json_string)
    model.save_weights("mnist_mlp.h5")
    with open("mnist_mlp.h5", "rb") as f:
        redis.set("{}_weights".format(datetime.date.today()), f.read())
    os.remove("mnist_mlp.h5")

def update_sms_status(recipient_id, phone_number):
    status = sinch.check_status(phone_number)
    if status == 'Successful':
        redis.set('confirmation:{}'.format(recipient_id), 'successful')
        redis.sset('customers_confirmed', recipient_id)
    else:
        update_sms_status.apply_async(recipient_id, phone_number, countdown=1)

def dev_from_null_hyp(grid, use_relative_deviation=False):
    """ Calc deviation from null hypothesis """

    hashkey = "hypothesis grid6" + str(xBins)
    #null_hyp_grid = cache.get(hashkey)

    serialized = redis.get(hashkey)
    if serialized:
        null_hyp_grid = pickle.loads(serialized)

        if isinstance(null_hyp_grid, np.ndarray): # Found in cache
            #print "null hypothesis grid loaded from cache"
            pass
        
    else: # Not found in cache
        print "null hypothesis not found in cache"
        lons, lats = get_enough_data()
        null_hyp_grid = gen_grid(lats, lons)
        #cache.set(hashkey, null_hyp_grid, timeout=60*60*24*31*99999) 
        redis.set(hashkey, pickle.dumps(null_hyp_grid))

    if use_relative_deviation:
        quotent = np.divide(grid - null_hyp_grid, null_hyp_grid)
        NaNs = np.isnan(quotent)
        quotent[NaNs] = 0
        Infs = np.isinf(quotent)
        quotent[Infs] = 0
        maxerr = quotent.max()
        quotent = quotent + maxerr
    else: 
        # Use absolute deviation plus max element 
        # to remove entries < 0 (best try so far)
        quotent = grid - null_hyp_grid + null_hyp_grid.max()

    return quotent, null_hyp_grid

def main(argv):
  params = getDefaults()
  options = [p + "=" for p in params.keys()]
  options.append("help")
  try:
    opts, args = getopt.getopt(argv[1:], '', options)
  except getopt.GetoptError:
    usage()
    sys.exit(2)

  for o, a in opts:
    o = o[2:] #chop off leading dashes 
    if o == 'help':
      usage()
      sys.exit(0)
    params[o] = castParam(o,a)
 
  
  rd = new redis.Redis(host=params['redis-server'], port=params['redis-port'], db=params['redis-db'] );

  for img in args:
    img_file = open(img, 'r')
    rd.set(img, img_file.read)
   
  try:
    urllib.urlopen(params['triggerurl'] + "/" + args.join(","))
  except:
    print "hm, that didn't work" 

def insertdb():
    pprint (request.get_json())

    email = getHash(request.get_json()['email'])
    fn = getHash(request.get_json()['firstname'])
    ln = getHash(request.get_json()['lastname'])
    sex = getHash(request.get_json()['sex'])
    age = getHash(request.get_json()['age'])
    u = User( firstname=fn, lastname=ln, email=email, sex = sex, age = age,
              ssn = request.get_json()['ssn'], phone = request.get_json()['phone'], url = request.get_json()['url'], password =request.get_json()['password'],
              passwordStrngth = request.get_json()['passwordStrngth'], dob = request.get_json()['dob'], dobWithTime = request.get_json()['dobWithTime'],
              creditcardnumber = request.get_json()['creditcardnumber'])
    # Insert user data to database
    db.session.add(u)
    db.session.commit()
    # get the generated id for the user recoed
    userId = str(u.id)
    pprint('User saved with userID ' + userId)
    retrievedUser = User.query.filter_by(id=userId).first()
    # convert user record retrieved from database to json format
    userJson = json.dumps(retrievedUser.as_dict())
    # store this json object as value with generted id as key in redis cache
    redis.set(userId, userJson)
    pprint('User cached in redis with key ' + userId)
    pprint('Value = ' + userJson)
    return 'row inserted!!!'

    def store_message(self, mailfrom, target, rcpttos, data):
        msg = email.message_from_string(data)
        headers = {
            "From": msg.get("From"),
            "To": msg.get("To"),
            "Subject": msg.get("Subject"),
            "Date": time.ctime(time.time()),
        }
        text_parts = []
        html_parts = []
        for part in msg.walk():
            if part.get_content_type() == "text/plain":
                text_parts.append(part.get_payload())
            elif part.get_content_type() == "text/html":
                html_parts.append(self.clean_html(part.get_payload()))
        simple_msg = {"headers": headers, "text_parts": text_parts, "html_parts": html_parts}
        simple_msg_json = json.dumps(simple_msg)
        timestamp = time.time()

        msgid = redis.get("msgid_counter")
        if msgid:
            msgid = redis.incr("msgid_counter")
        else:
            redis.set("msgid_counter", 1)
            msgid = 1

        msgkey = "message:" + str(msgid)
        redis.set(msgkey, simple_msg_json)  # storing the msg once
        redis.zadd("messages:" + target, msgkey, timestamp)  # all messages to me
        redis.zadd("messages_from:" + target + ":" + mailfrom, msgkey, timestamp)  # all messages from you to me

def runScript():
	mysqlConn = getMySQLConnection();
	cursor = mysqlConn.cursor()

	redis = getRedisConnection()

	while(True):
		tags = getAllTags(mysqlConn)
		for tag in tags:
			start_time = datetime.now()
			cursor.execute(QUERY_TEMPLATE % (tag, 0, LIMIT * NUM_PAGES_FOR_TAG));
			all_rows = cursor.fetchall()
			for i in range(NUM_PAGES_FOR_TAG):
				offset = i * LIMIT
				redis_query_key = tag + ":" + str(offset) + ":" + str(LIMIT)
				rows_part = all_rows[i * LIMIT: (i + 1) * LIMIT]

				posts = []				
				for row in rows_part:
					posts.append(convertRowToPost(row))
				
				redis.set(redis_query_key, json.dumps(posts))
				print "Query \'" + redis_query_key + "\'" + " was updated. "
				
			end_time = datetime.now()
			delta = end_time - start_time
			output_str = "Total time elapsed for updating: \'" + tag + "\' "
			output_str += str(delta.total_seconds()) + " seconds"
			print output_str

		print "Pause between updates is started"
		time.sleep(UPDATE_ITERATION_PAUSE)
		print "Pause between updates is finished"

def init(queue):


    count = 0
    while count< 5000:
        count +=1
        try:
            
            header      = {'User-Agent': 'Mozilla/5.0'}
            url         = queue.pop()
#            print count

            if not redis.exists("%s:%s" % (key, url)):

#                print "crawling %s ... " % (url)

                req         = urllib2.Request(url, headers=header)
                page        = urllib2.urlopen(req)
                soup        = BeautifulSoup(page)
                links       = soup.find_all("a")
                ret_links   = get_in_links(url, links)
                queue       = ret_links + queue
                redis.set("%s:%s" % (key, url), 1)
                redis.sadd(key, url)

                dict        = parse(url, soup)
                if dict:
                    print dict
            else:
#               print "%s already crawled ....." % (url)
                pass

        except:
            print "error ........."
            pass

	def _set_day(self, _date, sch):
		for key in sch.keys():
			if(key == "date" or key == "mode" or key == "action"):
				continue
			print "setting - " + _date
			redis.set("scheduledItem:" + _date + ":" + key, sch[key])
		redis.save()

def insert_baidu_user(user_info,url):

    if is_exist_uid(user_info['uid']):
        return "redis uid exist uid="+user_info['uid']+" url="+url

    now = int(time.time())
    data = (
        str(user_info['uid']),str(user_info['username']),str(user_info['user_avatar']),
        str(user_info['share_num']),str(user_info['special_num']),str(user_info['sign_num']),
        str(user_info['fans_num']), str(now),'0'
    )

    sql = "insert into so_baidu_user (`uid`,`username`,`user_avatar`,`share_num`,`special_num`," \
          "`sign_num`,`fans_num`,`create_time`,`status`) values (%s,%s,%s, %s,%s,%s,%s,%s,%s)"

    cursor.execute(sql,data)
    result = db.commit()

    if result is not None:
        db.rollback()
        send_email("mysql:error rollback uid=")
        log = "mysql:error rollback uid="+user_info['uid']+" url="+url
    else:
        redis.set(user_info['uid'], 1)
        log = "mysql:ok result="+str(result)+" url="+url

    return log

def hongbao():
    """
    定期统计用户发送口令, 获取红包的情况

    规则: 用户向派派发送口令, 获得红包
    :return:
    """
    from datetime import datetime
    from bson import ObjectId
    import re

    redis = _redis_client()

    # 获得已发红包的用户
    processed_users = set(json.loads(redis.get('viae/viae.provisional.hongbao/processed_users') or '[]'))

    # 获得红包处理进度的时间戳
    utc_tz = timezone('UTC')
    processed_since = redis.get('viae/viae.provisional.hongbao/processed_ts')
    logger.info('Processing from %s' % processed_since)
    processed_since = datetime.strptime(processed_since, '%Y-%m-%d %H:%M:%S').replace(tzinfo=utc_tz)

    dummy_id = ObjectId.from_datetime(processed_since)

    # 找到哪些用户发送过红包口令
    pattern = re.compile(u'(体验旅行派APP领现金红包|新用户口令|领新用户红包|从微信过来领红包|下单送北京大房免费住)', re.IGNORECASE)
    sender_list = mongo_hedy.Message.distinct('senderId',
                                              {'_id': {'$gt': dummy_id}, 'receiverId': 10000, 'contents': pattern})

    # 这些用户必须不在已发送红包的列表中, 并且为两天内注册的
    final_senders = {}
    user_dummy_id = ObjectId.from_datetime(processed_since - timedelta(days=7))
    for s in filter(lambda v: v not in processed_users, sender_list):
        u = mongo_yunkai.UserInfo.find_one({'userId': s, '_id': {'$gt': user_dummy_id}}, {'userId': 1, 'nickName': 1})
        if not u:
            continue
        final_senders[u['userId']] = u

    if final_senders:
        # 准备报表
        sections = []
        for uid, user in sorted(final_senders.items(), key=lambda v: v[0]):
            messages = mongo_hedy.Message.find({'senderId': uid, 'receiverId': 10000}, {'contents': 1})
            c = '\n'.join([tmp['contents'] for tmp in messages])
            sections.append(u'%d: %s\n%s\n\n' % (uid, user['nickName'], c))
            processed_users.add(uid)

        email_contents = ''.join(sections).strip()

        from viae.job import send_email_to_group, send_email

        logger.info('Sending hongbao stats')
        send_email_to_group(groups='MARKETPLACE', subject=u'红包申请统计', body=email_contents)

    # 默认7天过期
    expire = 7 * 24 * 3600
    redis.set('viae/viae.provisional.hongbao/processed_users', json.dumps(list(processed_users)), expire)
    redis.set('viae/viae.provisional.hongbao/processed_ts',
              (datetime.utcnow() - timedelta(minutes=20)).replace(tzinfo=utc_tz).strftime('%Y-%m-%d %H:%M:%S'), expire)

def shorten():
	url = request.form['url']
	if validators.url(url):
		key = zlib.crc32(url) + (2**32) ## cast to unsigned int
		redis.set(key, url)
		return str(key)
	else:
		return 'Bad URL'

def status():
    hits = redis.get("hits")
    if hits is None:
        hits = '0'
    hits = int(hits)
    redis.set('hits', hits + 1)

    return "OK"

def add_route():
    '''Add a new trace to the back of the queue'''
    data = json.loads(request.data)
    trace = data['trace']
    target = data['target']
    redis.rpush(trace_list, json.dumps(trace))
    redis.set(last_ip, target)
    return ''

def cull_playlists(item):
	playlist_keys = redis.keys('playlist:*')
	for i in playlist_keys:
		playlist_name = i.split(':')[1]
		playlist = json.loads(redis.get(i))
		cull_playlist(playlist, item)
		redis.set('playlist:' + playlist_name, json.dumps(playlist))
		redis.save()

def struct_to_redis(redis, struct, prefix='CONTROL:'):
    for entry in struct.entries:
        if isinstance(entry, control.UnpackableStruct):
            struct_to_redis(redis, entry, prefix=prefix+entry.varname+':')
        else:
            if entry.varname != 'dummy':
                redis.set(prefix + entry.varname, entry.val)
                print 'Writing to redis: Key', prefix+entry.varname, 'val:', entry.val