예제 #1
0
파일: bot.py 프로젝트: DefinedBoy/FirstAdd
def _all_(m):
    if m.chat.type == "group" or m.chat.type == "supergroup":
        uid = m.from_user.id
        cid = m.chat.id
        uname = m.from_user.first_name or "ادمین"
        status = redis.get(key + str(cid) + ":status") or "off"
        if bot.get_chat_member(cid, uid).status == "member":
            if status == "on":
                if redis.sismember(key + str(cid) + ":allow_list",
                                   uid) == False:
                    bot.delete_message(cid, m.message_id)
                    max_add = redis.get(key + str(cid) + ":max_add") or 3
                    if redis.sismember(key + str(cid) + ":warn_list",
                                       uid) == False:
                        text = """کاربر [{}](tg://user?id={}):

برای چت کردن در این گروه باید 3 نفر را به گروه دعوت کنید!""".format(
                            uname, uid, max_add)
                        bot.send_message(cid, text, parse_mode="Markdown")
                        redis.sadd(key + str(cid) + ":warn_list", uid)
        else:
            if m.text == "/panel":
                bot.delete_message(cid, m.message_id)
                text = "[{}](tg://user?id={}):\nبا دکمه های زیر حد اکثر تعداد دعوت ممبر ها را تایین کنید🎈😁".format(
                    uname, uid)
                bot.send_message(cid,
                                 text,
                                 parse_mode="Markdown",
                                 reply_markup=panel(cid))
예제 #2
0
def main():

    redis.set("hits:homepage", 2000)
    redis.set("hits:loginpage", 75)

    homepage = redis.get("hits:homepage")
    loginpage = redis.get("hits:loginpage")

    # Register our script with the Redis Python client and
    # return a callable object for invoking our script.
    stats = redis.register_script(stats_script)

    # Invoke our "sum" script.
    # This calls SCRIPT LOAD and then stores
    # the SHA1 digest of the script for future use.
    total = stats(["hits:homepage", "hits:loginpage"], ["sum"])
    assert (total == 2075)

    # Two more tests.
    max = stats(["hits:homepage", "hits:loginpage"], ["max"])
    assert (max == 2000)

    print('calling script to sum {} + {} = {}'.format(homepage, loginpage,
                                                      total))
    print('calling script get max {} or {} ? {}'.format(
        homepage, loginpage, max))
예제 #3
0
def resubmit_jobs():
    '''
    Examines the fetch and gather queues for items that are suspiciously old.
    These are removed from the queues and placed back on them afresh, to ensure
    the fetch & gather consumers are triggered to process it.
    '''
    if config.get('ckan.harvest.mq.type') != 'redis':
        return
    redis = get_connection()

    # fetch queue
    harvest_object_pending = redis.keys(get_fetch_routing_key() + ':*')
    for key in harvest_object_pending:
        date_of_key = datetime.datetime.strptime(redis.get(key),
                                                 "%Y-%m-%d %H:%M:%S.%f")
        # 3 minutes for fetch and import max
        if (datetime.datetime.now() - date_of_key).seconds > 180:
            redis.rpush(get_fetch_routing_key(),
                json.dumps({'harvest_object_id': key.split(':')[-1]})
            )
            redis.delete(key)

    # gather queue
    harvest_jobs_pending = redis.keys(get_gather_routing_key() + ':*')
    for key in harvest_jobs_pending:
        date_of_key = datetime.datetime.strptime(redis.get(key),
                                                 "%Y-%m-%d %H:%M:%S.%f")
        # 3 hours for a gather
        if (datetime.datetime.now() - date_of_key).seconds > 7200:
            redis.rpush(get_gather_routing_key(),
                json.dumps({'harvest_job_id': key.split(':')[-1]})
            )
            redis.delete(key)
예제 #4
0
def storage():
    redis.expire(session['current_user'], time=300)
    user_path = app.upload_path.joinpath(redis.get(session['current_user']).decode('utf-8')).resolve()
    user = redis.get(session['current_user']).decode('utf-8')
    cont = requests.get(app.file_server + "list/" + user, verify=False).content.decode()
    miniature = requests.get(app.file_server + "miniatures/" + user, verify=False).content.decode()

    files = json.loads(cont)['list']
    miniatures = []
    miniatures = json.loads(miniature)['list']

    files = []
    for filename in os.listdir(str(user_path)):
        data = []
        data.append(filename)
        data.append(str(os.stat(str(user_path) + "/" + filename).st_size) + "B")
        data.append("/slyko/dl/download/" + filename)
        data.append("/slyko/dl/delete/" + filename)
        data.append("/slyko/static/miniatures/" + filename)
        miniatures.append(filename)
        files.append(data)

    tokens = {}
    #for f in files:
     #   tokens[f]=creating_token(f,240).decode('utf-8')

    return render_template(
        'storage.html',user=redis.get(session['current_user']).decode('utf-8'),
        files_len=len(files), files=files, tokens=tokens, miniatures=miniatures)
예제 #5
0
def conductor(redis):
    groups = list(StaticGroups.objects.all()) + map(
        lambda x: x.group_info, Groups.objects.filter(behavior=1))
    for group in groups:
        if redis.get(group.group_id):
            day = datetime.utcnow()
            data_delta = timedelta(hours=24)
            if group.impression == False and int(
                    redis.get(group.group_id)
            ) >= group.limit_impressions and day - data_delta >= group.end_limit.replace(
                    tzinfo=None):
                redis.set(group.group_id, '0')
                group.limit_impressions = random_generate()
                group.save()
                continue
            if group.impression == False and int(redis.get(
                    group.group_id)) >= group.limit_impressions:
                group.impression = True
                group.save()
                redis.set(group.group_id, '0')
                continue
            if group.impression == True:
                delta = timedelta(hours=WAITING)
                if day - delta >= group.end_limit.replace(tzinfo=None):
                    group.impression = False
                    group.limit_impressions = random_generate()
                    group.save()
            else:
                continue
예제 #6
0
def get_new_group(message: telebot.types.Message):
    group = message.text
    user_id = message.from_user.id
    if group:
        group = group.upper()
    else:
        return
    kb = create_main_keyboard(user_id)
    emoji_list = list('😀😃😄😊🙃👽🤖🤪😝')
    emoji = random.choice(emoji_list)
    current_week = redis.get('current_week').decode('utf8')
    try:
        bot.delete_message(message.chat.id, message.message_id)
    except ApiException:
        pass
    try:
        groupoid = parsing.get_groupoid_or_raise_exception(group, redis)
    except exceptions.MpeiBotException as e:
        user_group = redis.get(f'user_group:{message.from_user.id}')
        if user_group:
            user_group = user_group.decode('utf8')
            continue_text = f'студент {user_group} {emoji}. Сегодня идет {current_week} неделя'
        else:
            continue_text = f'МЭИшник {emoji}. Сегодня идет {current_week} неделя'
        bot.send_message(message.chat.id, text=e.message)
        bot.send_message(message.chat.id, text=f'Привет, {continue_text}', reply_markup=kb)
        return
    redis.set(f'user_groupoid:{message.from_user.id}', value=groupoid)
    redis.set(f'user_group:{message.from_user.id}', value=group)
    continue_text = f'студент {group} {emoji}. Сегодня идет {current_week} неделя'
    bot.send_message(message.chat.id, f'Привет, {continue_text}', reply_markup=kb)
예제 #7
0
def getDefaultRoomCard(redis, groupId, userId, lastGroup=None):
    """
    获取用户的房卡数
    传入参数: redis,groupId(公会ID),userId(玩家ID),lastGroup(是否第一次)
    返回参数:默认房卡
    """
    provinceAgId = getTopAgentId(redis, groupId)
    defaultCard = redis.get(USER4AGENT_CARD % (provinceAgId, userId))
    log_util.debug(
        '[getDefaultRoomCard] groupId[%s] userId[%s] defaultCards[%s]' %
        (provinceAgId, userId, defaultCard))
    if not defaultCard:
        if lastGroup:
            #如果不是第一次加公会则返回当前的卡,没有则是0
            defaultCard = redis.get(USER4AGENT_CARD % (groupId, userId))
            if not defaultCard:
                return 0
            return defaultCard
        #如果是第一次则赠送默认房卡
        defaultCard = redis.hget(AGENT_TABLE % (provinceAgId),
                                 'defaultRoomCard')
        if not defaultCard:
            defaultCard = 0
    log_util.debug('[getDefaultRoomCard] return defaultCard[%s] groupId[%s]' %
                   (defaultCard, groupId))
    return defaultCard
예제 #8
0
def create_url():
    data = request.get_json()

    full_url = data['full_url']
    try:
        url_life = data['url_life']
    except KeyError:
        url_life = 90 * 24 * 60 * 60

    if not full_url.startswith('http://') and not full_url.startswith(
            'https://'):
        return make_response('<h2>Invalid URL format</h2>', 400)

    result = redis.get(full_url)
    if result != None:
        return f"Shortened URL for {full_url} already exists: /{result}\n\n"
    else:
        short_url = ''.join(random.choice(alphabet) for i in range(url_len))

        while redis.get(short_url):
            short_url = ''.join(
                random.choice(alphabet) for i in range(url_len))

        if url_life <= 0:
            url_life = 90 * 24 * 60 * 60  #90 days
        else:
            url_life = url_life * 24 * 60 * 60

        redis.set(full_url, short_url, url_life)
        redis.set(short_url, full_url, url_life)
        return f"Shortened URL for {full_url} is: /{short_url}\n\n"
예제 #9
0
 def random(self):
     youtube_ids = redis.srandmember("musicacommonset", 30)
     if not youtube_ids:
         return {"success": False}
     nonrecent = []
     total = 0
     for youtube_id in youtube_ids:
         youtube_id = youtube_id.decode()
         ltime = redis.get("musicatime.%s" % youtube_id)
         if ltime is None or time.time() - (float(ltime.decode())
                                            or 0) >= 3600:
             for i in range(
                     int(
                         redis.get("musicacommon.%s" % youtube_id).decode())
                     or 1):
                 nonrecent.append(youtube_id)
     if not youtube_ids:
         return {"success": False}
     youtube_id = query_search(random.choice(nonrecent),
                               search=False) if youtube_id else None
     if not youtube_id:
         return {"success": False}
     youtube_id = youtube_id[0]
     redis.rpush(
         "musicaqueue",
         json.dumps({
             "ytid": youtube_id,
             "uuid": str(uuid.uuid4())
         }))
     redis.rpush("musicaload", youtube_id)
     redis.set("musicatime.%s" % youtube_id, time.time())
     return {"success": True, "ytid": youtube_id}
예제 #10
0
def health_check():
    latest_block_num = None
    latest_block_hash = None

    stored_latest_block_num = redis.get(latest_block_redis_key)
    if stored_latest_block_num is not None:
        latest_block_num = int(stored_latest_block_num)

    stored_latest_blockhash = redis.get(latest_block_hash_redis_key)
    if stored_latest_blockhash is not None:
        latest_block_hash = stored_latest_blockhash.decode("utf-8")

    if latest_block_num is None or latest_block_hash is None:
        latest_block = web3.eth.getBlock("latest", True)
        latest_block_num = latest_block.number
        latest_block_hash = latest_block.hash

    health_results = _get_db_block_state(latest_block_num, latest_block_hash)

    verbose = request.args.get("verbose", type=str) == 'true'
    if verbose:
        # DB connections check
        health_results["db_connections"] = _get_db_conn_state()

    # Return error on unhealthy block diff if requested.
    enforce_block_diff = request.args.get("enforce_block_diff",
                                          type=str) == 'true'
    if enforce_block_diff and health_results[
            "block_difference"] > HEALTHY_BLOCK_DIFF:
        return jsonify(health_results), 500

    return jsonify(health_results), 200
예제 #11
0
def resubmit_jobs():
    if config.get('ckan.harvest.mq.type') != 'redis':
        return
    redis = get_connection()

    log.debug('_create_or_update_package')
    harvest_object_pending = redis.keys('harvest_object_id:*')
    for key in harvest_object_pending:
        date_of_key = datetime.datetime.strptime(redis.get(key),
                                                 "%Y-%m-%d %H:%M:%S.%f")
        if (datetime.datetime.now() - date_of_key
            ).seconds > 180:  # 3 minuites for fetch and import max
            redis.rpush('harvest_object_id',
                        json.dumps({'harvest_object_id': key.split(':')[-1]}))
            redis.delete(key)

    harvest_jobs_pending = redis.keys('harvest_job_id:*')
    for key in harvest_jobs_pending:
        date_of_key = datetime.datetime.strptime(redis.get(key),
                                                 "%Y-%m-%d %H:%M:%S.%f")
        if (datetime.datetime.now() -
                date_of_key).seconds > 7200:  # 3 hours for a gather
            redis.rpush('harvest_job_id',
                        json.dumps({'harvest_job_id': key.split(':')[-1]}))
            redis.delete(key)
def filters(body):  # noqa: E501
    """urlから判断する

     # noqa: E501

    :param body: 
    :type body: dict | bytes

    :rtype: InlineResponse200
    """
    if connexion.request.is_json:
        body = Body.from_dict(connexion.request.get_json())  # noqa: E501
    texts: List[str] = []
    cached_rslt: List[Tuple[int, float]] = []

    calc_urls: List[str] = []

    for i, url in enumerate(body.urls):
        if rslt := redis.get(url):  # type: ignore
            cached_rslt.append((i, float(rslt.decode())))
            continue

        calc_urls.append(url)
        try:
            text = oneURL2text.oneURL2text(url)
            texts.append(text)
        except Exception as e:
            with open(f"{__main__.DATA_PATH}/error.csv", mode="a") as f:
                f.writelines([str(e), ", ", url, "\n"])
            raise e
예제 #13
0
def Info(name: str = None,info = None): 
    x = connect(name)
    response = requests.get(x).content
    country = response
  
    result = redis.get(str(info))
    if not result:

        info = info.split(",")
        out = "{"
        websiteinfo = json.loads(country)[0]
        if websiteinfo is None:
            return "error in name"
        else:  
            for s in info:
                try:
                    out += s+":"+str(websiteinfo[s])+ ","
                except KeyError:
                    return "wrong info"
            out += "}"
            redis.setex (str(info),60,str(out))
            result = redis.get(str(info))
            return str(result) 
    else:
        return result      
예제 #14
0
def lambda_handler(event, context):
    try:
        redis.get('last_fed_timestamps')
        converted_last_fed = datetime.strptime(
            redis.get('last_fed_timestamps'), '%Y-%m-%d %H:%M:%S.%f')
        diff = (datetime.now() - converted_last_fed).total_seconds()

        if diff > 900.00:
            print('cat is hungry')
            if get_key('MESSAGE_NOT_FED_SENT') == 'False':
                email(NOT_FED_MESSAGE)
                print('Message sent')
                set_key('cat_status', 'hungry')
                set_key('MESSAGE_NOT_FED_SENT', 'True')
        elif get_key('cat_status') == 'ok':
            print('cat has been fed')
            if get_key('MESSAGE_FED_SENT') == 'False':
                email(FED_MESSAGE)
                print('Message sent')
                set_key('MESSAGE_FED_SENT', 'True')
        print('Seconds diff time is {}'.format(diff))

        return 'Job Finished'

    except Exception as e:
        print(e)
        raise e
예제 #15
0
def _user_get(authenticator_secret):
    if redis.exists('user_id_by_authenticator_secret_' + authenticator_secret):
        user_id = redis.get('user_id_by_authenticator_secret_' +
                            authenticator_secret)
        user_data = redis.get('user_by_id_' + user_id)
        return json.loads(user_data)
    return None
예제 #16
0
def resubmit_jobs():
    '''
    Examines the fetch and gather queues for items that are suspiciously old.
    These are removed from the queues and placed back on them afresh, to ensure
    the fetch & gather consumers are triggered to process it.
    '''
    if config.get('ckan.harvest.mq.type') != 'redis':
        return
    redis = get_connection()

    # fetch queue
    harvest_object_pending = redis.keys(get_fetch_routing_key() + ':*')
    for key in harvest_object_pending:
        date_of_key = datetime.datetime.strptime(redis.get(key),
                                                 "%Y-%m-%d %H:%M:%S.%f")
        # 3 minutes for fetch and import max
        if (datetime.datetime.now() - date_of_key).seconds > 180:
            redis.rpush(get_fetch_routing_key(),
                json.dumps({'harvest_object_id': key.split(':')[-1]})
            )
            redis.delete(key)

    # gather queue
    harvest_jobs_pending = redis.keys(get_gather_routing_key() + ':*')
    for key in harvest_jobs_pending:
        date_of_key = datetime.datetime.strptime(redis.get(key),
                                                 "%Y-%m-%d %H:%M:%S.%f")
        # 3 hours for a gather
        if (datetime.datetime.now() - date_of_key).seconds > 7200:
            redis.rpush(get_gather_routing_key(),
                json.dumps({'harvest_job_id': key.split(':')[-1]})
            )
            redis.delete(key)
예제 #17
0
def resubmit_jobs():
    if config.get('ckan.harvest.mq.type') != 'redis':
        return
    redis = get_connection()

    log.debug('_create_or_update_package')
    harvest_object_pending = redis.keys('harvest_object_id:*')
    for key in harvest_object_pending:
        date_of_key = datetime.datetime.strptime(redis.get(key),
                                                 "%Y-%m-%d %H:%M:%S.%f")
        if (datetime.datetime.now() - date_of_key).seconds > 180: # 3 minuites for fetch and import max
            redis.rpush('harvest_object_id',
                json.dumps({'harvest_object_id': key.split(':')[-1]})
            )
            redis.delete(key)

    harvest_jobs_pending = redis.keys('harvest_job_id:*')
    for key in harvest_jobs_pending:
        date_of_key = datetime.datetime.strptime(redis.get(key),
                                                 "%Y-%m-%d %H:%M:%S.%f")
        if (datetime.datetime.now() - date_of_key).seconds > 7200: # 3 hours for a gather
            redis.rpush('harvest_job_id',
                json.dumps({'harvest_job_id': key.split(':')[-1]})
            )
            redis.delete(key)
예제 #18
0
def index(request):
    if request.method == 'POST':
        keyword = request.POST['search']
        if not redis.get(keyword):
            # Here, we are only getting first 50 results
            search_params = {
                'key': YOUTUBE_API_KEY,
                'part': 'snippet',
                'q': keyword,
                'maxResults': '50',
                'order': 'date',
                'type': 'video'
            }
            search_response = requests.get(YOUTUBE_SEARCH_URL,
                                           params=search_params)
            json_data = search_response.json()
            next_token = json_data.get("nextPageToken")
            if next_token:
                tasks.fetch_all(
                    keyword, next_token
                )  # This task runs in the background to fetch the remaining 150 results
            videos_list = []
            video_data = OrderedDict()
            for r in search_response.json()['items']:
                videos_list.append(
                    r['id']
                    ['videoId'])  # gather all video ids to use for next query
                video_data[r['id']['videoId']] = r[
                    'snippet']  # save video data from search endpoint
            videos_params = {
                'key': YOUTUBE_API_KEY,
                'part': 'statistics',
                'id': ','.join(videos_list),
            }
            videos_response = requests.get(
                YOUTUBE_VIDEO_URL,
                params=videos_params)  # second query to get video views
            results = videos_response.json()['items']
            videos = []
            for r in results:
                data = video_data.get(r['id'])
                data['views'] = r['statistics'][
                    'viewCount']  # append views to video data
                data[
                    'url'] = f"https://www.youtube.com/watch?v={r['id']}"  # generate url
                videos.append(data)
            new_cache = json.dumps(videos)
            redis.setex(keyword, 600, new_cache)  # cache the result
            context = {'videos': videos, 'keyword': keyword, 'show_all': False}
            return render(request, "makr/result.html", context)

        cached = redis.get(keyword)
        cached_videos = json.loads(cached)
        context = {
            'videos': cached_videos,
            'keyword': keyword,
            'show_all': True
        }
        return render(request, "makr/result.html", context)
    return render(request, "makr/index.html")
예제 #19
0
def health_check():
    # can extend this in future to include ganache connectivity, how recently a block
    # has been added (ex. if it's been more than 30 minutes since last block), etc.
    latest_block_num = None
    latest_block_hash = None

    stored_latest_block_num = redis.get(latest_block_redis_key)
    if stored_latest_block_num is not None:
        latest_block_num = int(stored_latest_block_num)

    stored_latest_blockhash = redis.get(latest_block_hash_redis_key)
    if stored_latest_blockhash is not None:
        latest_block_hash = stored_latest_blockhash.decode("utf-8")

    if latest_block_num is None or latest_block_hash is None:
        latest_block = web3.eth.getBlock("latest", True)
        latest_block_num = latest_block.number
        latest_block_hash = latest_block.hash

    health_results = _get_db_block_state(latest_block_num, latest_block_hash)

    verbose = request.args.get("verbose", type=str) == 'true'
    if verbose:
        # DB connections check
        health_results["db_connections"] = _get_db_conn_state()

    if health_results["block_difference"] > HEALTHY_BLOCK_DIFF:
        return jsonify(health_results), 500

    return jsonify(health_results), 200
예제 #20
0
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)
예제 #21
0
def index():
    handle = unicode(redis.get("handle"), "utf-8")
    roomnum = unicode(redis.get("roomnum"), "utf-8")
    print("index:", handle, roomnum)
    return render_template("index.html", 
                           handle=handle, 
                           roomnum=roomnum
                           )
예제 #22
0
def fetch_cache_name(name: str = None):
    result = redis.get(name)
    if not result:
        country_info(name)
        result = redis.get(name)
        return str(result) + "new"
    else:
        return result
예제 #23
0
def finish():
    customer_queue = pickle.loads(redis.get('c_q'))
    currently_serving = pickle.loads(redis.get('c_s'))
    customer_queue.delete_by_uid(uuid.UUID(request.args.get('finish')))
    del currently_serving[uuid.UUID(request.args.get('finish'))]
    redis.set('c_s', pickle.dumps(currently_serving))
    redis.set('c_q', pickle.dumps(customer_queue))
    return redirect('/admin')
예제 #24
0
    def _handle_message(self, msg):
        """
        Forwards messages from Redis to the players directly connected to this
        instance.
        """
        self._debug('RECEIVED - {}', extra=[str(msg)])
        if msg['type'] != 'message' or msg['channel'] != self.topic:
            return  # Ignore messages we don't need

        msg = json_loads(msg['data'])

        # If we have the artist, we're responsible for adjusting game state
        must_pass = False
        artist = self._get_artist()
        score = None
        guesser = None
        if self._has_artist(artist):
            if msg.verb == 'GUESSED':
                if msg.player_name == artist:
                    self._error('artist ({}) submitted a guess',
                                extra=[artist])
                else:
                    word = redis.get(self.word_key)
                    # TODO: Correct is only set for clients connected to this instance.
                    msg.correct = word.lower() == msg.word.lower()
                    if msg.correct:
                        guesser = msg.player_name
                        score = redis.zincrby(self.players_key,
                                              msg.player_name, 1)
                        word_won(word)
                        must_pass = True
            elif msg.verb == 'SKIPPED':
                if msg.player_name == artist:
                    self._error('artist ({}) voted to skip', extra=[artist])
                else:
                    voted = redis.scard(self.skip_key)
                    total = redis.zcard(self.players_key) - 1

                    if voted * 2 > total:
                        must_pass = True
            elif msg.verb == 'ENDED':
                if msg.player_name == artist:
                    must_pass = True
                # TODO: Player name will be sent on other instances
                del msg.player_name

        # Repeat the message to all players
        for p in self.players:
            if msg.verb == 'PASSED' and msg.player_name == p.name:
                # Add the word to the passed message for the correct player
                special = Message(msg)
                special.word = redis.get(self.word_key)
                gevent.spawn(p.send, special)
            else:
                gevent.spawn(p.send, msg)

        if must_pass:
            self._pass_turn(artist, guesser=guesser, score=score)
예제 #25
0
def read_redis(data):

    import redis
    #redis = redis.Redis(host = 'redis',port = 6379, decode_responses=True)
    redis = redis.Redis()
    for d in redis.scan_iter():
        if data == d: return redis.get(data)

    return redis.get(data)
예제 #26
0
def shorten_details(short_id):
    link_target = redis.get('url-target:' + short_id)
    if link_target is None:
        raise NotFound()
    click_count = int(redis.get('click-count:' + short_id) or 0)
    return render_template('details.html', 
                        short_id=short_id, 
                        click_count=click_count,
                        link_target=link_target)
예제 #27
0
파일: app.py 프로젝트: jrabbit/MoscaMorta
def kill():
    redis.incr('kills')
    if request.forms.get("name"):
        user = request.forms.get("name")
        # print user
        redis.incr(user)
        return template('<b>Flies killed: {{num_killed}}</b>!', num_killed=redis.get(user))
    else:
        return template('<b>Flies killed: {{num_killed}}</b>!', num_killed=redis.get('kills'))
def add_total_score_to_one(location,
                           max_price=10000000.0,
                           min_price=0,
                           min_lot_size=0,
                           price_weight=1,
                           transit_weight=1,
                           size_weight=1):
    if transit_weight < 0:
        walk_weight = 1
        log.info("Reset negative walk weight to 1")

    if price_weight < 0:
        price_weight = 1
        log.info("Reset negative bike weight to 1")

    if size_weight < 0:
        size_weight = 1
        log.info("Reset negative transit weight to 1")

    weighted_sum = price_weight + transit_weight + size_weight
    if weighted_sum <= 0:
        # Someone entered weird values
        log.info("Resetting weights due to weighted_sum being <=0")
        weighted_sum = 3
        price_weight = transit_weight = size_weight = 1

    try:
        transit_score = redis.get(location.listing_key +
                                  "/downtown_commute_score")
        if transit_score is None:
            transit_score = 0

        listing = json.loads(redis.get(location.listing_key))
        price = listing['price']
        if price > max_price or price < min_price:
            price_score = 0
        else:
            price_score = 10

        if 'lot_size' in listing:
            size = listing['lot_size']
            try:
                size = [int(s) for s in size.split() if s.isdigit()][-1]
                if size > min_lot_size:
                    size_score = 10
            except:
                log.warning('lot size not parsed for ' + location.listing_key)
                size_score = 0
        else:
            size_score = 0
        score = (price_score * price_weight + size_score * size_weight +
                 float(transit_score) * transit_weight) / (weighted_sum)
        print(score)
        redis.set(location.listing_key + "/total_score", score)
    except Exception as e:
        log.exception(traceback.format_exc())
예제 #29
0
    def _handle_message(self, msg):
        """
        Forwards messages from Redis to the players directly connected to this
        instance.
        """
        self._debug('RECEIVED - {}', extra=[str(msg)])
        if msg['type'] != 'message' or msg['channel'] != self.topic:
            return                              # Ignore messages we don't need

        msg = json_loads(msg['data'])

        # If we have the artist, we're responsible for adjusting game state
        must_pass = False
        artist = self._get_artist()
        score = None
        guesser = None
        if self._has_artist(artist):
            if msg.verb == 'GUESSED':
                if msg.player_name == artist:
                    self._error('artist ({}) submitted a guess', extra=[artist])
                else:
                    word = redis.get(self.word_key)
                    # TODO: Correct is only set for clients connected to this instance.
                    msg.correct = word.lower() == msg.word.lower()
                    if msg.correct:
                        guesser = msg.player_name
                        score = redis.zincrby(self.players_key, msg.player_name, 1)
                        word_won(word)
                        must_pass = True
            elif msg.verb == 'SKIPPED':
                if msg.player_name == artist:
                    self._error('artist ({}) voted to skip', extra=[artist])
                else:
                    voted = redis.scard(self.skip_key)
                    total = redis.zcard(self.players_key) - 1

                    if voted * 2 > total:
                        must_pass = True
            elif msg.verb == 'ENDED':
                if msg.player_name == artist:
                    must_pass = True
                # TODO: Player name will be sent on other instances
                del msg.player_name

        # Repeat the message to all players
        for p in self.players:
            if msg.verb == 'PASSED' and msg.player_name == p.name:
                # Add the word to the passed message for the correct player
                special = Message(msg)
                special.word = redis.get(self.word_key)
                gevent.spawn(p.send, special)
            else:
                gevent.spawn(p.send, msg)

        if must_pass:
            self._pass_turn(artist, guesser=guesser, score=score)
예제 #30
0
파일: app.py 프로젝트: raymonst/flask-app
def index():
    visitors = redis.get('visitors')
    os = redis.get('osdata')

    num = 0 if visitors is None else int(visitors)
    num += 1

    redis.set('visitors', num)
    user_agent = request.user_agent
    return render_template('index.html', number=num, user_agent=user_agent)
예제 #31
0
def get_bytecoin_price():
    last_price = redis.get("bytecoin_price")
    if last_price >= 350:
        diff = -50
    elif last_price <= 122:
        diff = 32
    else:
        diff = random.randint(-5, 5)
    redis.set("bytecoin_price", last_price + diff)
    return redis.get("bytecoin_price")
예제 #32
0
def background_thread():
    """Send server generated events to clients."""
    while True:
        socketio.sleep(1)
        data = {
            "miner_count": redis.get("num_miners"),
            "bytecoin_price": get_bytecoin_price(),
            "total_work": redis.get("combined_mining_speed")
        }
        socketio.emit("stats", data, namespace="/bytecoin")
예제 #33
0
    def run_time(self, function, interval, *args, **kwargs):
        while True:
            duration = time.time() - float(redis.get('before'))

            if duration > interval:
                print(duration)
                function(*args, **kwargs)
                redis.set('before', time.time())
                print('updated')
                redis.publish(REDIS_CHAN, redis.get('activity_data'))
            gevent.sleep(interval / 10)
예제 #34
0
def _get_like_list(ad_id):
    likes = redis.keys('user:like:*:%s' % ad_id)
    like_list = []

    for like in likes:
        l_user = redis.get(like)
        l_date = redis.get('date:%s' % ":".join(like.split(':')[1:]))

        like_list.append({'user': l_user, 'date': l_date})

    return like_list
예제 #35
0
    def join(self, player):
        if player.table == self:
            return                              # Already part of this table.

        if player.table is not None:
            player.table.leave(player)          # Player has to leave old table

        msg = Message('JOINED')                 # Tell all the other players
        msg.player_name = player.name           # that a new player has joined.
        self.send(msg)

        player.table = self                     # Register the new player with
        self.players.append(player)             # this table.

        # Get a list of all the other players on this table
        others = redis.zrange(self.players_key, 0, -1)

        # Check if the player exists (race condition I guess)
        score = redis.zscore(self.players_key, player.name)
        if score is None:
            # Add new player to the player list
            redis.zadd(self.players_key, player.name, 0)

            # Add player to the turn list if he/she wasn't already there
            redis.zadd(self.turns_key, player.name, time.time())

        # Prepare joined messages for all existing players
        msgs = []
        for other in others:
            if other == player.name:
                continue
            msg = Message('JOINED')
            msg.player_name = other
            msgs.append(msg)

        # Prepare passed message to set correct turn
        current = self._get_artist()
        msg = Message('PASSED', player_name=current)
        if player.name == current:
            msg.word = redis.get(self.word_key)

            end_time = time.time() + 120
            if not redis.setnx(self.end_key, end_time):
                # Clock's already started!
                end_time = redis.get(self.end_key)
        else:
            end_time = redis.get(self.end_key)
            assert(end_time is not None)
        msg.end_time = end_time
        msgs.append(msg)

        # Send all the prepared messages
        gevent.joinall([gevent.spawn(player.send, x) for x in msgs])
예제 #36
0
def process_next():
    customer_queue = pickle.loads(redis.get('c_q'))
    processing, count = customer_queue.find_next_eligible()
    if not processing:
        return redirect('/admin')
    print(processing.name)
    processing.exp = time() + 300
    currently_serving = pickle.loads(redis.get('c_s'))
    currently_serving[processing.uid] = processing
    print('expiring at ', currently_serving[processing.uid].exp)
    redis.set('c_s', pickle.dumps(currently_serving))
    return redirect('/admin')
예제 #37
0
    def join(self, player):
        if player.table == self:
            return  # Already part of this table.

        if player.table is not None:
            player.table.leave(player)  # Player has to leave old table

        msg = Message('JOINED')  # Tell all the other players
        msg.player_name = player.name  # that a new player has joined.
        self.send(msg)

        player.table = self  # Register the new player with
        self.players.append(player)  # this table.

        # Get a list of all the other players on this table
        others = redis.zrange(self.players_key, 0, -1)

        # Check if the player exists (race condition I guess)
        score = redis.zscore(self.players_key, player.name)
        if score is None:
            # Add new player to the player list
            redis.zadd(self.players_key, player.name, 0)

            # Add player to the turn list if he/she wasn't already there
            redis.zadd(self.turns_key, player.name, time.time())

        # Prepare joined messages for all existing players
        msgs = []
        for other in others:
            if other == player.name:
                continue
            msg = Message('JOINED')
            msg.player_name = other
            msgs.append(msg)

        # Prepare passed message to set correct turn
        current = self._get_artist()
        msg = Message('PASSED', player_name=current)
        if player.name == current:
            msg.word = redis.get(self.word_key)

            end_time = time.time() + 120
            if not redis.setnx(self.end_key, end_time):
                # Clock's already started!
                end_time = redis.get(self.end_key)
        else:
            end_time = redis.get(self.end_key)
            assert (end_time is not None)
        msg.end_time = end_time
        msgs.append(msg)

        # Send all the prepared messages
        gevent.joinall([gevent.spawn(player.send, x) for x in msgs])
예제 #38
0
def getlatest(request):
    
    global redis
    
    int_fields = { 'ExcitementShortTerm', 'ExcitementLongTerm', 'FrustrationScore', 'LowerfaceValue', 'UpperfaceValue'}
    js_dict = { f: int(round(100 * float(redis.get(f) or 0))) for f in int_fields }

    str_fields = {'Lowerface', 'Upperface'}
    js_dict.update( {f: redis.get(f) for f in str_fields} )

    #create data
    print js_dict
    return js_dict
예제 #39
0
def hello():
#    to_store = read_tags()
#    to_store.append('test tag not on MER')
#    redis.delete('allTags')
#    for tag in to_store:
#        redis.rpush('allTags', tag)
    hint = redis.get('hint').decode('utf-8')
    sol = redis.get('sol').decode('utf-8')
    stored_tags = redis.lrange('allTags', 0, -1)
    MER_tags = read_tags()
    not_on_MER = [item for item in stored_tags if item not in MER_tags]
    return render_template("communicate.html",
                           myhint=hint, mysol=sol, tags=MER_tags, tags_not_on_MER=not_on_MER)
예제 #40
0
파일: tests_get.py 프로젝트: CodeJuan/rfid
def test():
    r = requests.get('http://localhost:8000/products/ProductItems')
    print r.text
    data = json.loads(r.text)
    lost = []
    for rfid in data:
        cur = rfid['RFID']
        if redis.get(cur) == None:
            print 'lost',cur
            lost.append(cur)

    redis.set('lost', lost)
    print redis.get('lost')
예제 #41
0
    def _listen_worker(self, channel_id, factory, processor):
        connection = redis.Redis(*self.address)
        self._create_channel(connection, channel_id)
        
        collection = connection[self._db][channel_id]
        cursor = redis.sort((redis.get("_id"),("_id", ASC)))

        while True:
            for envelope in cursor.interkeys():
                msg = take_from_envelope(envelope, factory)
                processor.process(envelope[FROM_FIELD], envelope[TO_FIELD], channel_id, msg);
                collection.update({"_id": envelope["_id"]}, {"$set": {READ_FIELD: True}})
            self._sleep(0.05)
           cursor = redis.sort((redis.get(TO_FIELD: self.get_id())),("_id", ASC))
예제 #42
0
파일: cron.py 프로젝트: weseethrough/Adtech
def create_report(redis, id, name, email):
    print "%s <%s>/%d" % (name, email, id)

    # Gather data
    hits = int(redis.get('hit:%s' % id) or '0')
    hps = int(redis.get('honeypot:%s' % id) or '0')

    print "  %d of %d blocked" % (hits-hps, hits)
    
    if hits > 0:
        send_report(name, email, hits, hps)

        # Clear processed data
        redis.decr('hit:%s' % id, hits)
        redis.decr('honeypot:%s' % id, hps)
예제 #43
0
def hello():
	selbots = [];
	for key in sorted(["host:DevSystem0.local","host:DevSystem1.local","host:DevSystem2.local","host:DevSystem3.local"]):
		if (redis.get(key)):
			s = json.loads(redis.get(key))
			# time in seconds since epoch as int
			now = int(time.time())
			mins = (now - s['time']) / 60;
			rel = natural.date.delta(now, s['time'], words=False)
			s['server'] = key
			s['minutes_ago'] = mins
			s['time_ago_relative'] = rel[0]
			selbots.append(s)

	return render_template('house.html', servers=selbots)
예제 #44
0
def runScript():
	conn = getMySQLConnection();
	cursor = conn.cursor()

	tags = getAllTags(conn)

	redis = getRedisConnection()

	print "Redis Fetch (With caching)\n\n\n"

	query_durations = [0.0] * QUERIES_AMOUNT

	for i in range(QUERIES_AMOUNT):
		current_tag = random.choice(tags)

		start_time = datetime.now()

		redis_query_key = current_tag + ":" + str(QUERY_OFFSET) + ":" + str(QUERY_LIMIT)
		posts_json = redis.get(redis_query_key)
		posts = json.loads(posts_json)

		end_time = datetime.now()
		delta = end_time - start_time
		sec = delta.total_seconds()
		query_durations[i] = sec

		for post in posts:
			printPost(post)
			print '\n-----------------\n'

		print ("Query #" + str(i) + " with tag \'" + current_tag + "\' finished."
				" Duration: " + str(delta.total_seconds()) + " sec\n\n\n\n\n")


	print "\n\nAverage query time: " + str(sum(query_durations) / float(QUERIES_AMOUNT))
예제 #45
0
파일: views.py 프로젝트: maxberggren/sinus
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
예제 #46
0
    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
예제 #47
0
def get_static(cache_ignore=False):
    if not cache_ignore:
        champions = redis.get('static_champions')
        items = redis.get('static_items')
        if champions and items:
            champions = json.loads(champions)
            items = json.loads(items)
            items = {int(x):y for x,y in items.iteritems()}
            return champions, items

    champions = riot.static_get_champion_list(champ_data='tags,info')['data']
    items = riot.static_get_item_list(item_list_data='depth,from')['data']
    items = {int(x):y for x,y in items.iteritems()}
    redis.set('static_champions', json.dumps(champions))
    redis.set('static_items', json.dumps(items))
    return champions, items
예제 #48
0
def image(filename):
  gs_file_string = redis.get(filename)
  buffer_image = BytesIO()
  gs_image = Image.open(BytesIO(gs_file_string))
  gs_image.save(buffer_image, 'JPEG', quality=90)
  buffer_image.seek(0)
  return Response(buffer_image.getvalue(), mimetype='image/jpeg')
예제 #49
0
파일: app.py 프로젝트: EugeneLiang/gif2fb
def done():
    id = request.form.get('id', None)

    if id:
        return redis.get(id.split('.gif')[0])
    else:
        return 'error'
예제 #50
0
def rate(user_id, value, film_id=None, actor_id=None, director_id=None, type=1, overwrite=True, check_if_exists=False):
    user_key = "user:%s:ratings" % user_id

    key = _rating_key(film_id, actor_id, director_id, type)

    assert user_id

    if not overwrite or check_if_exists:
        exists = redis.get("user:%s:rating:%s" % (user_id, key)) is not None
        if not overwrite and exists:
            return exists
    else:
        exists = None

    with redis.pipeline() as pipe:
        if value:
            if type == 1 and film_id:
                pipe.hset(user_key, film_id, value)
                pipe.sadd("users", user_id)
            pipe.hset("ratings:%s" % key, user_id, value)
            pipe.set("user:%s:rating:%s" % (user_id, key), value)
        else:
            if type == 1:
                pipe.hdel(user_key, film_id)
            pipe.hdel("ratings" + key, user_id)
            pipe.delete("user:%s:rating:%s" % (user_id, key))
        pipe.execute()
    return exists
예제 #51
0
def get_or_incr():
    name = 'counter'
    post_key = 'incrBy'

    if request.method == 'POST' and post_key in request.form:
        redis.incr(name, request.form[post_key])
    return redis.get(name) or '0'
예제 #52
0
def index():
    value = redis.get('RUNNING')
    if value == 'true':
        running = True
    else:
        running = False
    return render_template('index.html', running=running)
예제 #53
0
def get_queue(session, redis=redis.Redis()):
    proposal_id = Utils._proposal_id(session)
    if proposal_id is not None:
        serialized_queue = redis.get("mxcube:queue:%d" % proposal_id)
    else:
        serialized_queue = None

    return new_queue(serialized_queue)
예제 #54
0
def get_features(key_prefix, id, type=None):
    # TODO - type support
    # assert key_prefix.startswith('cache_user')
    key = "%s:%s" % (key_prefix, id)
    features = redis.get(key)
    if not features:
        return dict()
    return pickle.loads(features)
예제 #55
0
def check_price_and_notify(delay):  
    while 1:        
        print "Notification is triggered!"   
        # loading latest products in memory 
        # build list product with decreasing prices 
        products_prices_before = build_hash_from_json(json.loads(redis.get('optimusprice.prices')))
        status_code, prices = get_all_prices()
        
        if (status_code == 200): 
            products_prices_now = build_hash_from_json(prices)
        else: 
            products_prices_now = products_prices_before

        users = redis.smembers("optimusprice.subscriptions.users")
        print "Subscribed users: ", users
        for chat_id in users:            
            user_id = redis.get("optimusprice.mapping." + str(chat_id))                                        
            # updating user subscriptions
            status_code, products = get_likes_for_user(user_id)
            if status_code == 200:
                for p in products: 
                  redis.sadd("optimusprice.subscriptions." + str(chat_id), p)


        products_ids_to_notify = []        
        print products_prices_before.keys()
        print products_prices_now.keys()
        for p in products_prices_before.keys():
            if products_prices_now.get(p) is not None:
                if float(products_prices_now.get(p)['price']) < float(products_prices_before.get(p)['price']):
                    products_ids_to_notify.append(p)    
        print "products_ids_to_notify ", products_ids_to_notify
        users = redis.smembers("optimusprice.subscriptions.users")
        print "subscribed users ", users
        for u in users:                  
            products_likes = map(int, redis.smembers("optimusprice.subscriptions." + str(u)))                    
            print "likes for user %s : %s" %(str(u), str(products_likes))
            products_intersection = set(products_ids_to_notify).intersection(products_likes)
            print "products_intersection for user %s : %s" %(str(u), str(products_intersection))
            if len(products_intersection) > 0:
                print "Notifying %s about %s" % (u,str(products_intersection))
                for pp in products_intersection:
                    bot.sendMessage(u, "Prices has changed for :" + products_prices_before.get(pp)['name'])             
                    f = open('images/%s.jpg' % pp, 'rb')  # some file on local disk
                    bot.sendPhoto(u, f)
        time.sleep(delay)
예제 #56
0
def status():
    hits = redis.get("hits")
    if hits is None:
        hits = '0'
    hits = int(hits)
    redis.set('hits', hits + 1)

    return "OK"
예제 #57
0
 def _thaw(prefix):
     import os.path
     thawed = None
     try:
         thawed = jsonpickle.decode(redis.get(prefix + PluginDirectory.FREEZER_KEY))
     except:
         pass
     return thawed
예제 #58
0
def get_data(artist_name):
    '''Get the logged data for a given artist name''' 
    res_string = redis.get(artist_name)
    res_dict = json.loads(res_string)

    res = jsonify(res_dict)
    res.headers['Access-Control-Allow-Origin'] = '*'
    return res
예제 #59
0
 def isOnline(self):
     """
     Returns true if the user is considered online by the system.
     """
     value = redis.get("user:%s:ping" % self.id) or 0
     if (time.time() - float(value)) < 30:
         return True
     return False