Example #1
0
    def clear(self):
        search = self.key_prefix + '*'
        for key in cache.iter_keys(search):
            cache.delete(key)

        for key in cache.keys('*.home.*'):
            cache.delete(key)
Example #2
0
    def get(self, request):
        """成交分笔明细"""
        db = self.mongo_conn.hotcow
        self.collection = db.trading_data
        tasks = []
        if Base(TradingDay, **{
                'day': str(datetime.date.today())
        }).findfilter():
            sk_all = cache.iter_keys('cache_code_info_*')
            for i in sk_all:
                sk_info = cache.get(i)
                if sk_info and sk_info[
                        'market_value'] and sk_info['market_value'] <= 500:
                    if not Base(
                            MyChoiceData, **{
                                'code': sk_info['code'],
                                'trading_day': str(datetime.date.today()),
                            }).findfilter():
                        tasks.append(self._constantly_deal(
                            sk_info['exchange']))

            asyncio.set_event_loop(asyncio.new_event_loop())  # 创建新的协程
            loop = asyncio.get_event_loop()
            loop.run_until_complete(asyncio.wait(tasks))
            loop.close()
        return Response({'MainFlows': 'data update node'})
Example #3
0
    def test_iter_keys(self):
        cache.set("foo1", 1)
        cache.set("foo2", 1)
        cache.set("foo3", 1)

        # Test simple result
        result = set(cache.iter_keys("foo*"))
        assert result == set(["foo1", "foo2", "foo3"])

        # Test limited result
        result = list(cache.iter_keys("foo*", itersize=2))
        assert len(result) == 3

        # Test generator object
        result = cache.iter_keys("foo*")
        assert next(result) != None
Example #4
0
    def get(self, request):
        data = {}
        if 'q' in self.request.GET:
            company_name = self.request.GET['q'].upper()
            cols = list(
                cache.get(next(cache.iter_keys(f"*{company_name}*"))).keys())
            rows = []
            for row in cache.iter_keys(f"*{company_name}*"):
                r = []
                for col in cols:
                    r.append(cache.get(row)[col])
                rows.append(r)

            data['cols'] = cols
            data['rows'] = rows
        return JsonResponse(data)
Example #5
0
    def get(self, request):
        """同步历史资金流向"""
        data = request.GET
        tasks = []
        sk_all = cache.iter_keys('cache_code_info_*')
        if data and 'code' in data:
            for i in sk_all:
                code = str(i).split('_')[-1]
                url = f"{settings.QT_URL3}data/view/ggdx.php?t=2&r=0.8876465514316253" \
                      f"&q={code.replace('~', '')}"
                tasks.append(
                    self._read_data(url=url,
                                    num_day='day',
                                    code=code.split('~')[-1]))
        else:
            code_list = []
            for i in sk_all:
                code_list.append(str(i).split('_')[-1].replace('~', ''))
            times_number = 100
            for num in range(0, len(code_list) // times_number + 1):
                url = f"{settings.QT_URL3}data/view/ggdx.php?t=3&d=5&q=" \
                      f"{','.join(code_list[num * times_number:times_number * (num + 1)])}"
                tasks.append(self._read_data(url=url, num_day='many_day'))

        asyncio.set_event_loop(asyncio.new_event_loop())  # 创建新的协程
        loop = asyncio.get_event_loop()
        loop.run_until_complete(asyncio.wait(tasks))
        loop.close()
        return Response({'MainFlows': 'data update node'})
Example #6
0
    def test_iter_keys(self):
        """Test the iter_keys cache operation"""
        cache.set("foo1", 1)
        cache.set("foo2", 1)
        cache.set("foo3", 1)

        # Test simple result
        result = set(cache.iter_keys("foo*"))
        self.assertEqual(result, {"foo1", "foo2", "foo3"})

        # Test limited result
        result = list(cache.iter_keys("foo*", itersize=2))
        self.assertEqual(len(result), 3)

        # Test generator object
        result = cache.iter_keys("foo*")
        self.assertIsNotNone(next(result))
Example #7
0
    def save(self, *args, **kwargs) -> None:

        super(BaseModel, self).save(*args, **kwargs)
        cache_dict: dict = self.flush_cache_keys() or self.CACHE_DICT

        if cache_dict['keys']:
            [cache.delete(key) for key in cache_dict['keys']]
        if cache_dict['match']:
            [cache.delete(key) for key in [cache.iter_keys(key) for key in cache_dict['match']]]
Example #8
0
def getKeywords(request):
	"""
	获取联想词列表,GET请求,直接返回关键词列表

	请求参数:	amount:返回的关键词的数量,默认为5
				word:用户输入的关键词
	"""
	amount = request.GET.get('amount', '5')
	word = request.GET['word']

	if len(word) > 5 or int(amount) < 1:		# 输入数据校验
		raise Exception

	keywords = []
	cache.iter_keys(word + '*')
	for i in range(0, int(amount)):
		key = next(cache.iter_keys(word + '*'))
		keywords.append(key)

	return JsonResponse(keywords, safe = False)
Example #9
0
    def test_iter_keys(self):
        cache = caches["default"]
        if isinstance(cache.client, ShardClient):
            self.skipTest("ShardClient doesn't support iter_keys")

        cache.set("foo1", 1)
        cache.set("foo2", 1)
        cache.set("foo3", 1)

        # Test simple result
        result = set(cache.iter_keys("foo*"))
        self.assertEqual(result, {"foo1", "foo2", "foo3"})

        # Test limited result
        result = list(cache.iter_keys("foo*", itersize=2))
        self.assertEqual(len(result), 3)

        # Test generator object
        result = cache.iter_keys("foo*")
        self.assertNotEqual(next(result), None)
    def test_iter_keys(self):
        cache = caches["default"]
        if isinstance(cache.client, ShardClient):
            self.skipTest("ShardClient doesn't support iter_keys")

        cache.set("foo1", 1)
        cache.set("foo2", 1)
        cache.set("foo3", 1)

        # Test simple result
        result = set(cache.iter_keys("foo*"))
        self.assertEqual(result, {"foo1", "foo2", "foo3"})

        # Test limited result
        result = list(cache.iter_keys("foo*", itersize=2))
        self.assertEqual(len(result), 3)

        # Test generator object
        result = cache.iter_keys("foo*")
        self.assertNotEqual(next(result), None)
Example #11
0
    def post(self, request, query):
        response = HttpResponse(content_type='text/csv')
        response[
            'Content-Disposition'] = f'attachment; filename={query.lower()}.csv'

        writer = csv.writer(response)
        company_name = query.upper()

        cols = list(
            cache.get(next(cache.iter_keys(f"*{company_name}*"))).keys())
        writer.writerow(cols)

        rows = []
        for row in cache.iter_keys(f"*{company_name}*"):
            r = []
            for col in cols:
                r.append(cache.get(row)[col])
            rows.append(r)
            writer.writerow(r)

        return response
Example #12
0
    def test_iter_keys(self):
        cache = caches["default"]
        _params = cache._params
        _is_shard = _params["OPTIONS"]["CLIENT_CLASS"] == "django_redis.client.ShardClient"

        if _is_shard:
            return

        cache.set("foo1", 1)
        cache.set("foo2", 1)
        cache.set("foo3", 1)

        # Test simple result
        result = set(cache.iter_keys("foo*"))
        self.assertEqual(result, {"foo1", "foo2", "foo3"})

        # Test limited result
        result = list(cache.iter_keys("foo*", itersize=2))
        self.assertEqual(len(result), 3)

        # Test generator object
        result = cache.iter_keys("foo*")
        self.assertNotEqual(next(result), None)
Example #13
0
    def _forward_outbound(self,
                          command_category=0,
                          category=0,
                          id=0,
                          command=0,
                          verification=''):
        """
        后端->前端
        :param flag:
        :return:
        """
        try:
            if self.category_id_list is None or self.terminal_id_list is None:
                self._websocket.send(json.dumps({'code': 400}))  # 发送一个400状态码
                return
            # 暴力拿全部keys,后面可以根据model的名称获得, 注意iter_keys返回一个生成器
            cache_names = [i for i in cache.iter_keys("*")]

            # 打开配置文件, 获取终端信息键值对
            with open('./conf/category.conf') as f:
                terminals = eval(f.read())

            exist_category_id_list = []
            exist_terminal_id_list = []
            # 改成(category_id:terminal_id) 方便查询
            # set是去重
            category_terminal_set = set([(k, v) for k in self.category_id_list
                                         for v in self.terminal_id_list])
            # print("键值对", category_terminal_set)
            for category_id, terminal_id in category_terminal_set:
                category_id = int(category_id)
                terminal_id = int(terminal_id)
                for i in cache_names:  # 遍历缓存中的名称
                    for name in terminals.values():  # 遍历配置表中的内容,组合名称查看是否存在于缓存中
                        if (name + '%02d' % category_id +
                                '%02d' % terminal_id) == i:
                            exist_category_id_list.append(category_id)
                            exist_terminal_id_list.append(terminal_id)

            data = json.dumps({
                "data": {
                    "category_id_list": exist_category_id_list,
                    "terminal_id_list": exist_terminal_id_list
                }
            })
            self._websocket.send(data)
        finally:
            # 届时写个logger
            # print("autoBridge回应状态结束")
            pass
Example #14
0
    def test_iter_keys(self):
        cache = get_cache("default")
        _params = cache._params
        _is_shard = _params["OPTIONS"]["CLIENT_CLASS"] == "django_redis.client.ShardClient"

        if _is_shard:
            return

        cache.set("foo1", 1)
        cache.set("foo2", 1)
        cache.set("foo3", 1)

        # Test simple result
        result = set(cache.iter_keys("foo*"))
        self.assertEqual(result, set(["foo1", "foo2", "foo3"]))

        # Test limited result
        result = list(cache.iter_keys("foo*", itersize=2))
        self.assertEqual(len(result), 3)

        # Test generator object
        result = cache.iter_keys("foo*")
        self.assertNotEqual(next(result), None)
def get_pokemons_from_cache():
	pokemons_list = []
	name_list = []
	pokemons_in_cache = cache.iter_keys("pokemon_*")
	for pokemon_in_cache in pokemons_in_cache:
		name_list.append(str(pokemon_in_cache))
		# pokemons_list.append(cache.get(str(pokemon_in_cache)))
	temp_list = cache.get_many(name_list)

	for key, pokemon_data in temp_list.items():
		pokemon_data.update({'image': '/static/mapview/icons/{0}.png'.format(str(pokemon_data['pokemon_id']))})

		pokemons_list.append(pokemon_data)
	return pokemons_list
Example #16
0
    def get(self, request):
        """同步当天资金流向"""
        if Base(TradingDay, **{'day': datetime.date.today()}).findfilter():
            tasks = []
            sk_all = cache.iter_keys('cache_code_info_*')
            for i in sk_all:
                code = cache.get(i)
                tasks.append(self._ma_day(code['exchange'], ))

            asyncio.set_event_loop(asyncio.new_event_loop())  # 创建新的协程
            loop = asyncio.get_event_loop()
            loop.run_until_complete(asyncio.wait(tasks))
            loop.close()
        return Response({'MainFlows': 'data update node'})
    def test_iter_keys(self):
        cache = caches['default']
        _params = cache._params
        _is_shard = _params['OPTIONS']['CLIENT_CLASS'] == 'django_redis.client.ShardClient'

        if _is_shard:
            return

        cache.set('foo1', 1)
        cache.set('foo2', 1)
        cache.set('foo3', 1)

        # Test simple result
        result = set(cache.iter_keys('foo*'))
        self.assertEqual(result, {'foo1', 'foo2', 'foo3'})

        # Test limited result
        result = list(cache.iter_keys('foo*', itersize=2))
        self.assertEqual(len(result), 3)

        # Test generator object
        result = cache.iter_keys('foo*')
        self.assertNotEqual(next(result), None)
Example #18
0
def readRecentMsgFromCache(roomId, refreshTime):
    '''
    A method to read a list of message from cache since last refreshTime
    '''
    global message_prefix
    it = cache.iter_keys(message_prefix % (roomId) + '*')

    # Iterate all the message in the cache
    result = []
    for key in it:
        metadata = cache.get(key)
        if long(metadata['time']) > long(refreshTime): # the msg is newer than the last refresh time
            result.append(metadata)
    return result
Example #19
0
    def get(self, request):
        """同步历史交易"""
        tasks = []
        sk_all = cache.iter_keys('cache_code_info_*')
        for i in sk_all:
            code = cache.get(i)
            tasks.append(self._close_day(code['sid'], code['exchange']))

        if tasks:
            asyncio.set_event_loop(asyncio.new_event_loop())  # 创建新的协程
            loop = asyncio.get_event_loop()
            loop.run_until_complete(asyncio.wait(tasks))
            loop.close()

        return Response({'HistoryDeals': 'data update node'})
Example #20
0
def readUsersFromCache(roomId):
    '''
    A method to read a list of users in the chatroom from cache
    @param roomId: the id of the chatroom
    @return: a list of Userinfo of users in the chatroom
    '''
    global user_prefix
    it = cache.iter_keys(user_prefix % (roomId) + '*')
    
    # Iterate all the user in the it
    result = []
    for key in it:
        username = cache.get(key)
        user = User.objects.get(username__exact = username)
        ui = UserInfo.objects.get(user = user)
        result.append(ui)
    return result
Example #21
0
def get_top_girls():
    '''
    Getting top 100 girls by hits number
    '''
    cached = cache.get("cached_result")
    if cached:
        return cached

    name_list = [post for post in cache.iter_keys("girl_*")]
    result_post_dict = cache.get_many(name_list)
    sorted_post_list = sorted(result_post_dict.items(),
                              key=lambda e: e[1][1],
                              reverse=True)
    top_ids_list = [
        int(top_post[0].split('_')[1]) for top_post in sorted_post_list[:100]
    ]
    cache.set("cached_result", top_ids_list, timeout=90)
    return top_ids_list
Example #22
0
    def handle(self, *args, **options):

        to_create = []

        for key in cache.iter_keys("visit_*"):

            user_id, ad_id = self.parse_key(key)
            value = cache.get(key)

            if not value:
                continue

            number = value['number']
            modified = value['actual']

            if number == 1:

                if modified:

                    obj = Visits(user_id=user_id, number=number, ad_id=ad_id)
                    to_create.append(obj)
            else:
                if modified:
                    Visits.objects.filter(user_id=user_id, ad_id=ad_id).update(number=number)

            cache.set(key, {'number': number, 'actual': False}, timeout=None)

        # Если имя не определено, значит кеш был пустым
        try:
            key
        except NameError:
            self.stdout.write(self.style.SUCCESS('No visits to create or update'))
            return

        Visits.objects.bulk_create(to_create)

        self.stdout.write(self.style.SUCCESS('Successfully create visits'))
def execute_limit_order(order):
    # get all the correspond key in cache
    s_b = 'sell'
    if order.s_b == 'sell':
        s_b = 'buy'
    product_code = order.product_code
    keys = cache.iter_keys(s_b + '-' + product_code + '-' + '*')
    for key in keys:
        value = cache.get(key)
        print(value.dict())
        # the seller's price < buyer's price
        print(key)
        if value.s_b == 'sell' and value.price <= order.price and value.remain > 0:
            transaction_service.execute_limit_market_transaction(order, value)
        elif value.s_b == 'buy' and value.price >= order.price and value.remain > 0:
            transaction_service.execute_limit_market_transaction(order, value)
        if order.remain == 0:
            break

    # the new order hasn't be done
    if order.remain != 0:
        cache.add(get_key(order), order, timeout=None)
    else:
        transaction_service.save_completed_order(order.id)
Example #24
0
def execute_limit_order(order):
    # get all the correspond key in cache
    s_b = 'sell'
    if order.s_b == 'sell':
        s_b = 'buy'
    product_code = order.product_code
    keys = cache.iter_keys(s_b + '-' + product_code + '-' + '*')
    for key in keys:
        value = cache.get(key)
        print(value.dict())
        # the seller's price < buyer's price
        print(key)
        if value.s_b == 'sell' and value.price <= order.price and value.remain > 0:
            transaction_service.execute_limit_market_transaction(order, value)
        elif value.s_b == 'buy' and value.price >= order.price and value.remain > 0:
            transaction_service.execute_limit_market_transaction(order, value)
        if order.remain == 0:
            break

    # the new order hasn't be done
    if order.remain != 0:
        cache.add(get_key(order), order, timeout=None)
    else:
        transaction_service.save_completed_order(order.id)
Example #25
0
 def purge(domain, languages):
     for key in cache.iter_keys('dcl_sites:domain_languages:%s:*' % domain):
         if key.split(':')[-1] not in languages:
             cache.delete(key)
Example #26
0
File: jobs.py Project: groig/forge
def release_all_locks_of_user(user_id: str) -> None:
    for key in cache.iter_keys('lock:*'):
        if str(cache.get(key)) == user_id:
            cache.delete_pattern(key)
Example #27
0
 def purge(domains):
     for key in cache.iter_keys('dcl_sites:domain:*'):
         if key not in domains:
             cache.delete(key)
Example #28
0
def sync_database():
    for session_key in cache.iter_keys("fav_item_id_*"):
        item_id = session_key.split('_')[-1]
        exist_records = LofterModel.objects.filter(id=int(item_id))[0]
        exist_records.fav_click = int(cache.get(session_key))
        exist_records.save()
Example #29
0
 def handle(self, **options):
     count = 0
     for key in cache.iter_keys("*"):
         count += 1
     self.stdout.write("Cleared {} cache keys".format(format(count, ",")))
     cache.clear()
Example #30
0
 def purge(domain, urls):
     for key in cache.iter_keys('dcl_sites:domain_url:%s:*' % domain):
         if key.split(':')[-1] not in urls:
             cache.delete(key)