gp-server.git - Gitblit

			@@ -8,9 +8,11 @@
			import time

			import constant
			from code_attribute import code_nature_analyse
			from db.redis_manager_delegate import RedisUtils
			from third_data import kpl_block_util, kpl_api, kpl_util
			from utils import global_util, tool
			from trade.trade_manager import MarketSituationManager
			from utils import global_util, tool, buy_condition_util
			from log_module import log, async_log_util
			from db import redis_manager_delegate as redis_manager

			@@ -97,9 +99,11 @@
			if price_rate > 0.07:
			jx_blocks_info = self.get_jx_blocks_cache(code)
			if not jx_blocks_info:
			start_time = time.time()
			blocks = kpl_api.getCodeBlocks(code)
			async_log_util.info(logger_kpl_block_can_buy,
			f"{code}:获取到精选板块-{blocks} 耗时:{int(time.time() - start_time)}s")
			self.save_jx_blocks(code, blocks, current_limit_up_blocks)
			async_log_util.info(logger_kpl_block_can_buy, f"{code}:获取到精选板块-{blocks}")
			else:
			# 还没涨停的需要更新精选板块更新精选板块
			if abs(float(buy_1_price) - float(limit_up_price)) >= 0.001:
			@@ -114,17 +118,22 @@
			UPDATE_TIME_SPACE = 5 * 60

			if time.time() - jx_blocks_info[1] > UPDATE_TIME_SPACE:
			start_time = time.time()
			# 距离上次更新时间过去了5分钟
			blocks = kpl_api.getCodeBlocks(code)
			async_log_util.info(logger_kpl_block_can_buy,
			f"{code}:获取到精选板块（更新）-{blocks} 耗时:{int(time.time() - start_time)}s")
			self.save_jx_blocks(code, blocks, current_limit_up_blocks)
			async_log_util.info(logger_kpl_block_can_buy, f"{code}:获取到精选板块（更新）-{blocks}")


			elif price_rate > 0.03:
			# 添加备用板块
			if not self.get_jx_blocks_cache(code, by=True):
			start_time = time.time()
			blocks = kpl_api.getCodeBlocks(code)
			self.save_jx_blocks(code, blocks, current_limit_up_blocks, by=True)
			async_log_util.info(logger_kpl_block_can_buy, f"{code}:获取到精选板块(备用)-{blocks}")
			async_log_util.info(logger_kpl_block_can_buy,
			f"{code}:获取到精选板块(备用)-{blocks} 耗时:{int(time.time() - start_time)}s")
			except Exception as e:
			logger_kpl_block_can_buy.error(f"{code} 获取板块出错")
			logger_kpl_block_can_buy.exception(e)
			@@ -170,7 +179,7 @@
			class LimitUpCodesPlateKeyManager:
			# 今日涨停原因
			today_limit_up_reason_dict = {}
			today_total_limit_up_reason_dict = {}
			__today_total_limit_up_reason_dict = {}
			total_code_keys_dict = {}
			total_key_codes_dict = {}
			__redisManager = redis_manager.RedisManager(1)
			@@ -178,7 +187,7 @@
			def __get_redis(self):
			return self.__redisManager.getRedis()

			# 获取今日涨停数据，格式：[(代码,涨停原因)]
			# 获取今日涨停数据，格式：[(代码,涨停原因,精选板块列表)]
			def set_today_limit_up(self, datas):
			temp_dict = {}
			if datas:
			@@ -191,10 +200,17 @@
			self.set_today_total_limit_up(datas)

			# 设置今日历史涨停数据
			def set_today_total_limit_up(self, datas):
			# 格式：(代码,涨停原因,精选板块列表)
			@classmethod
			def set_today_total_limit_up(cls, datas):
			for item in datas:
			code = item[0]
			self.today_total_limit_up_reason_dict[code] = item[1]
			# 设置涨停代码的板块及原因
			cls.__today_total_limit_up_reason_dict[code] = (item[1], item[2])

			@classmethod
			def get_today_limit_up_reason(cls, code):
			return cls.__today_total_limit_up_reason_dict.get(code)

			# 今日涨停原因变化
			def set_today_limit_up_reason_change(self, code, from_reason, to_reason):
			@@ -427,10 +443,17 @@

			# 返回key集合(排除无效板块),今日涨停原因,今日历史涨停原因,历史涨停原因,二级,精选板块
			def get_plate_keys(self, code):
			"""
			获取代码的板块
			@param code:
			@return: （板块关键词集合,今日涨停原因+涨停推荐原因,今日历史涨停原因,历史涨停原因,精选板块）
			"""
			keys = set()
			k1 = set()
			if code in LimitUpCodesPlateKeyManager.today_total_limit_up_reason_dict:
			k1 = {LimitUpCodesPlateKeyManager.today_total_limit_up_reason_dict[code]}

			limit_up_reason_info = LimitUpCodesPlateKeyManager.get_today_limit_up_reason(code)
			if limit_up_reason_info:
			k1 = {limit_up_reason_info[0]} \| set(limit_up_reason_info[1])
			# 加载今日历史原因,暂时不需要历史原因了
			k11 = set() # RedisUtils.smembers(self.__get_redis(), f"kpl_limit_up_reason_his-{code}")
			k2 = self.__CodesPlateKeysManager.get_history_limit_up_reason_cache(code)
			@@ -448,12 +471,14 @@
			if jingxuan_block_info:
			jingxuan_blocks = jingxuan_block_info[0]
			k4 \|= set(jingxuan_blocks) # set([x[1] for x in jingxuan_blocks])
			for k in [k1, k11, k2, k3, k4]:
			keys \|= k

			# 排除无效的涨停原因
			keys = keys - set(constant.KPL_INVALID_BLOCKS)

			if k1:
			# 涨停过
			keys \|= k1
			keys = keys - set(constant.KPL_INVALID_BLOCKS)
			if not keys:
			# 获取不到涨停原因
			keys \|= k4
			keys = keys - set(constant.KPL_INVALID_BLOCKS)
			return keys, k1, k11, k2, k3, k4


			@@ -486,9 +511,36 @@
			l2_trade_util.forbidden_trade(code, msg=msg)
			logger_kpl_block_can_buy.info(msg)

			# 返回内容(是否可买, 是否为独苗, 描述信息)
			# 是否需要激进买
			@classmethod
			def __is_block_can_buy(cls, code, block, current_limit_up_datas, code_limit_up_reason_dict,
			def __is_need_active_buy(cls, code, block, current_rank, open_limit_up_count):
			"""
			板块是否需要激进买入
			规则：根据身位判断是否需要激进买，根据时间划分
			@param code: 代码
			@param block: 板块名称
			@param current_rank: 目前在板块中的身位，从0开始
			@param open_limit_up_count: 开1的数量
			@return:
			"""

			real_current_rank = max(current_rank - open_limit_up_count, 0)

			TIME_STR_RANGES = ["10:00:00", "10:30:00", "11:00:00", "13:00:00", "13:30:00", "14:00:00", "14:30:00",
			"15:00:00"]
			TIME_INT_RANGES = [int(x.replace(':', '')) for x in TIME_STR_RANGES]
			MAX_RANKS = [3, 3, 2, 2, 1, 0, 0, 0]
			now_time_str = tool.get_now_time_str().replace(':', '')
			for i in range(len(TIME_INT_RANGES)):
			if int(now_time_str) <= TIME_INT_RANGES[i]:
			if MAX_RANKS[i] > real_current_rank:
			return True
			break
			return False

			# 返回内容(是否可买, 是否为独苗, 描述信息, 是否为强势主线, 是否需要激进买)
			@classmethod
			def __is_block_can_buy(cls, code, block, current_limit_up_datas, code_limit_up_reasons_dict,
			yesterday_current_limit_up_codes, limit_up_record_datas, current_limit_up_block_codes_dict,
			high_level_code_blocks=None, high_level_block_codes=None):
			# 独苗判断
			@@ -499,13 +551,14 @@
			block_codes = current_limit_up_block_codes_dict.get(block)
			if block_codes is None:
			block_codes = set()

			if not block_codes:
			# 高位板泛化板块中无板块
			if not high_level_block_codes.get(block):
			return False, True, f"{block}:板块无涨停", False
			return False, True, f"{block}:板块无涨停", False, False
			elif len(block_codes) == 1 and code in block_codes:
			if not high_level_block_codes.get(block):
			return False, True, f"{block}:板块只有当前代码涨停", False
			return False, True, f"{block}:板块只有当前代码涨停", False, False
			# 可以买的最大排名
			# open_limit_up_codes = kpl_block_util.get_shsz_open_limit_up_codes(code, block, limit_up_record_datas,
			# code_limit_up_reason_dict)
			@@ -515,7 +568,8 @@
			# ---------------------------判断强势主线-------------------------
			is_strong_block = False
			for d in current_limit_up_datas:
			if d[5] != block:
			bs = kpl_util.get_current_limit_up_reasons(d)
			if block not in bs:
			general_blocks = high_level_code_blocks.get(d[0])
			if not general_blocks or block not in general_blocks:
			# 没在泛化板块中
			@@ -552,6 +606,7 @@

			# 获取代码的初次涨停时间
			first_limit_up_time = time.time()
			# if limit_up_record_datas:
			for r in limit_up_record_datas:
			if r[3] == code:
			first_limit_up_time = int(r[5])
			@@ -559,13 +614,16 @@
			# 获取主板实时身位,剔除高位板
			current_shsz_rank, front_current_shsz_rank_codes = kpl_block_util.get_code_current_rank(code, block,
			current_limit_up_datas,
			code_limit_up_reason_dict,
			code_limit_up_reasons_dict,
			yesterday_current_limit_up_codes,
			exclude_first_codes,
			len(
			current_open_limit_up_codes),
			shsz=True,
			limit_up_time=first_limit_up_time)
			# 计算是否需要激进买入
			is_active_buy = cls.__is_need_active_buy(code, block, current_shsz_rank, len(current_open_limit_up_codes))

			# record_shsz_rank, record_shsz_rank_codes = kpl_block_util.get_code_record_rank(code, block,
			# limit_up_record_datas,
			# code_limit_up_reason_dict,
			@@ -573,17 +631,24 @@
			# shsz=True)
			if int(tool.get_now_time_str().replace(":", "")) <= int("094000") and is_strong_block:
			# 强势主线加强势10分钟
			return True, False, f"【{block}】：强势主线+强势10分钟", is_strong_block
			return True, False, f"【{block}】：强势主线+强势10分钟", is_strong_block, is_active_buy

			if current_shsz_rank < len(current_open_limit_up_codes) + max_rank:
			return True, False, f"【{block}】前排代码：{current_shsz_rank}", is_strong_block
			return True, False, f"【{block}】前排代码：{current_shsz_rank}", is_strong_block, is_active_buy
			else:
			# k_format = code_nature_analyse.CodeNatureRecordManager().get_k_format_cache(code)
			# if k_format and k_format[8][0]:
			# # 具有辨识度
			# return True, False, f"【{block}】具有辨识度", is_strong_block
			# 看自由流通市值是否小于20亿
			if is_strong_block and current_shsz_rank < len(current_open_limit_up_codes) + max_rank + 1:
			zyltgb = global_util.zyltgb_map.get(code)
			if zyltgb and zyltgb < 20 * 100000000:
			return True, False, f"【{block}】强势板块自由流通市值({zyltgb})小于20亿", is_strong_block
			return False, False, f"【{block}】前排代码：{front_current_shsz_rank_codes} 超过{len(current_open_limit_up_codes) + max_rank}个", is_strong_block
			zyltgb_as_yi = round(global_util.zyltgb_map.get(code) / 100000000,
			2) if code in global_util.zyltgb_map else None
			situation = MarketSituationManager().get_situation_cache()
			zylt_threshold_as_yi = buy_condition_util.get_zyltgb_threshold(situation)
			if zyltgb_as_yi and zylt_threshold_as_yi[2] <= zyltgb_as_yi <= zylt_threshold_as_yi[3]:
			return True, False, f"【{block}】强势板块自由流通市值({zyltgb_as_yi})大于{zylt_threshold_as_yi[2]}亿小于{zylt_threshold_as_yi[3]}亿", is_strong_block, is_active_buy
			return False, False, f"【{block}】前排代码：{front_current_shsz_rank_codes} 超过{len(current_open_limit_up_codes) + max_rank}个", is_strong_block, is_active_buy

			# 过时的代码
			# if open_limit_up_codes:
			@@ -604,6 +669,101 @@
			#
			# return False, f"板块-{block}: top4涨停板块，非主板开1,不为主板龙1（实时身位-{current_shsz_rank}:{front_current_shsz_rank_codes},历史身位-{record_shsz_rank}）"

			@classmethod
			def __is_block_can_buy_new(cls, code, block, current_limit_up_datas, code_limit_up_reasons_dict,
			yesterday_current_limit_up_codes, limit_up_record_datas,
			current_limit_up_block_codes_dict,
			high_level_code_blocks=None, high_level_block_codes=None):
			"""
			该票的板块是否可以买
			@param code:
			@param block:
			@param current_limit_up_datas:
			@param code_limit_up_reasons_dict:
			@param yesterday_current_limit_up_codes:
			@param limit_up_record_datas:
			@param current_limit_up_block_codes_dict:
			@param high_level_code_blocks:
			@param high_level_block_codes:
			@return:
			"""
			# 独苗判断
			if high_level_code_blocks is None:
			high_level_code_blocks = {}
			if high_level_block_codes is None:
			high_level_block_codes = {}
			block_codes = current_limit_up_block_codes_dict.get(block)
			if block_codes is None:
			block_codes = set()
			# 历史涨停代码
			block_codes_records = set()
			if limit_up_record_datas:
			for k in limit_up_record_datas:
			if block in code_limit_up_reasons_dict.get(k[3]):
			block_codes_records.add(k[3])

			if not block_codes:
			# 高位板泛化板块中无板块
			if not high_level_block_codes.get(block):
			return False, True, f"{block}:板块无涨停", False, False, 0, 0, 0
			elif len(block_codes) == 1 and code in block_codes:
			if not high_level_block_codes.get(block):
			return False, True, f"{block}:板块只有当前代码涨停", False, False, 0, 0, 0
			# 可以买的最大排名
			# open_limit_up_codes = kpl_block_util.get_shsz_open_limit_up_codes(code, block, limit_up_record_datas,
			# code_limit_up_reason_dict)
			current_open_limit_up_codes = kpl_block_util.get_shsz_open_limit_up_codes_current(code, block,
			current_limit_up_datas)

			is_strong_block = False

			# 最多买老几
			RANKS = [5, 4, 3, 3, 3, 2, 2]
			RANK_TIMES = ["10:00:00", "10:30:00", "11:00:00", "11:30:00", "13:30:00", "14:00:00", "15:00:00"]
			now_time_str = tool.get_now_time_str()
			max_rank = 2
			for i in range(len(RANK_TIMES)):
			if tool.trade_time_sub(now_time_str, RANK_TIMES[i]) <= 0:
			max_rank = RANKS[i]
			break

			# 需要排除的老大的代码
			exclude_first_codes = set()

			# 获取主板开1的代码

			# 剔除高位板
			if current_open_limit_up_codes and yesterday_current_limit_up_codes:
			current_open_limit_up_codes -= yesterday_current_limit_up_codes

			# 获取代码的初次涨停时间
			first_limit_up_time = time.time()
			# if limit_up_record_datas:
			for r in limit_up_record_datas:
			if r[3] == code:
			first_limit_up_time = int(r[5])

			# 获取主板实时身位,剔除高位板
			current_shsz_rank, front_current_shsz_rank_codes = kpl_block_util.get_code_current_rank(code, block,
			current_limit_up_datas,
			code_limit_up_reasons_dict,
			yesterday_current_limit_up_codes,
			exclude_first_codes,
			len(
			current_open_limit_up_codes),
			shsz=True,
			limit_up_time=first_limit_up_time)

			# 计算是否需要激进买入
			is_active_buy = cls.__is_need_active_buy(code, block, current_shsz_rank, len(current_open_limit_up_codes))

			if current_shsz_rank < len(current_open_limit_up_codes) + max_rank:
			return True, False, f"【{block}】前排代码：{current_shsz_rank}", is_strong_block, is_active_buy, current_shsz_rank, len(
			block_codes), len(block_codes_records)
			else:
			return False, False, f"【{block}】前排代码：{front_current_shsz_rank_codes} 超过{len(current_open_limit_up_codes) + max_rank}个", is_strong_block, is_active_buy, current_shsz_rank, len(
			block_codes), len(block_codes_records)

			# 获取可以买的板块
			# current_limit_up_datas: 今日实时涨停
			# latest_2_day_limit_up_datas：最近2天的实时涨停（不含今日）
			@@ -621,29 +781,19 @@
			if limit_up_record_datas:
			for d in limit_up_record_datas:
			if d[2] in constant.KPL_INVALID_BLOCKS and d[3] in before_blocks_dict:
			code_limit_up_reason_dict[d[3]] = list(before_blocks_dict.get(d[3]))[0]
			code_limit_up_reasons_dict[d[3]] = {list(before_blocks_dict.get(d[3]))[0]}
			else:
			code_limit_up_reason_dict[d[3]] = d[2]
			return code_limit_up_reason_dict
			code_limit_up_reasons_dict[d[3]] = {d[2]}
			# 不包含推荐原因
			# if d[6]:
			# code_limit_up_reasons_dict[d[3]] \|= set(d[6].split("、"))
			return code_limit_up_reasons_dict

			if current_limit_up_datas is None:
			current_limit_up_datas = []

			# 获取目标代码板块
			keys, k1, k11, k2, k3, k4 = cls.__TargetCodePlateKeyManager.get_plate_keys(code)
			# log.logger_kpl_debug.info("{}关键词：今日-{},今日历史-{},历史-{},二级行业-{},代码板块-{}", code, k1, k11, k2, k3, k4)
			keys = set()
			if k1:
			for k in k1:
			if k not in constant.KPL_INVALID_BLOCKS:
			keys.add(k)
			# 始终获取精选板块
			if True:
			# 获取
			if k4:
			# 当涨停原因没有时才取精选板块
			keys \|= k4
			keys = keys - constant.KPL_INVALID_BLOCKS

			# log.logger_kpl_debug.info("{}最终关键词：{}", code, keys)

			@@ -652,31 +802,35 @@
			fresults = []
			if not keys:
			return fresults, set()
			code_limit_up_reason_dict = {}
			code_limit_up_reasons_dict = {}
			load_code_block()
			for block in keys:
			can_buy, unique, msg, is_strong = cls.__is_block_can_buy(code, block, current_limit_up_datas,
			code_limit_up_reason_dict,
			yesterday_current_limit_up_codes,
			limit_up_record_datas,
			current_limit_up_block_codes_dict,
			high_level_code_blocks=high_level_general_code_blocks,
			high_level_block_codes=high_level_general_block_codes)
			fresults.append((block, can_buy, unique, msg, is_strong))
			can_buy, unique, msg, is_strong, is_active_buy, current_rank, block_limit_up_count, block_limit_up_record_count = cls.__is_block_can_buy_new(
			code, block,
			current_limit_up_datas,
			code_limit_up_reasons_dict,
			yesterday_current_limit_up_codes,
			limit_up_record_datas,
			current_limit_up_block_codes_dict,
			high_level_code_blocks=high_level_general_code_blocks,
			high_level_block_codes=high_level_general_block_codes)
			fresults.append((block, can_buy, unique, msg, is_strong, is_active_buy, current_rank, block_limit_up_count,
			block_limit_up_record_count))
			return fresults, keys

			# 是否可以下单
			# 返回：可以买的板块,是否独苗,消息
			# 可买的板块, 是否独苗, 消息, 可买的强势板块, 关键词, 激进买的板块
			@classmethod
			def can_buy(cls, code):
			if constant.TEST:
			return ["测试"], True, cls.BLOCK_TYPE_NONE, [], set()
			return [("测试", 0, 1, 1)], True, cls.BLOCK_TYPE_NONE, [], set(), ["化工"]
			# if True:
			# # 测试
			# return True, "不判断板块身位"
			return cls.__can_buy_compute_result_dict.get(code)

			# 返回:(可以买的板块列表, 是否是独苗, 消息简介,可买的强势主线)
			# 返回:(可以买的板块列表, 是否是独苗, 消息简介,可买的强势主线, 激进买入板块列表)
			@classmethod
			def __compute_can_buy_blocks(cls, code, current_limit_up_datas, limit_up_record_datas,
			yesterday_current_limit_up_codes, before_blocks_dict,
			@@ -695,7 +849,7 @@
			high_level_general_code_blocks,
			high_level_general_block_codes)
			if not blocks_compute_results:
			return False, True, f"没有找到板块", [], keys
			return False, True, f"没有找到板块", [], keys, []
			codes_delegate = set(cls.__CodesTradeStateManager.get_codes_by_trade_states_cache(
			{trade_manager.TRADE_STATE_BUY_DELEGATED, trade_manager.TRADE_STATE_BUY_PLACE_ORDER}))
			codes_success = set(cls.__CodesTradeStateManager.get_codes_by_trade_states_cache(
			@@ -737,9 +891,9 @@
			can_buy_strong_blocks = []
			unique_count = 0
			msg_list = []

			active_buy_blocks = []
			for r in blocks_compute_results:
			# r的数据结构(板块,是否可以买,是否独苗,消息,是否是强势板块)
			# r的数据结构(板块,是否可以买,是否独苗,消息,是否是强势板块, 激进买入信息)
			if r[2]:
			# 独苗
			unique_count += 1
			@@ -747,24 +901,31 @@
			# 强势主线最多同时挂3只票，最多成交2只票
			MAX_DELEGATE_COUNT = 3 if r[4] else 2
			MAX_DEAL_COUNT = 2 if r[4] else 1
			if r[0] in trade_success_blocks_count and len(trade_success_blocks_count[r[0]]) >= MAX_DEAL_COUNT:
			msg_list.append(f"【{r[0]}】有成交代码：{trade_success_blocks_count[r[0]]}")
			continue
			if r[0] in trade_delegate_blocks_count and len(trade_delegate_blocks_count[r[0]]) >= MAX_DELEGATE_COUNT:
			msg_list.append(f"【{r[0]}】已挂单：{trade_delegate_blocks_count[r[0]]}")
			continue
			can_buy_blocks.append(r[0])
			# if r[0] in trade_success_blocks_count and len(trade_success_blocks_count[r[0]]) >= MAX_DEAL_COUNT:
			# msg_list.append(f"【{r[0]}】有成交代码：{trade_success_blocks_count[r[0]]}")
			# continue
			# if r[0] in trade_delegate_blocks_count and len(trade_delegate_blocks_count[r[0]]) >= MAX_DELEGATE_COUNT:
			# msg_list.append(f"【{r[0]}】已挂单：{trade_delegate_blocks_count[r[0]]}")
			# continue
			if len(r) > 8:
			can_buy_blocks.append((r[0], r[6], r[7], r[8]))
			else:
			# （板块名称,身位,板块涨停数量）
			can_buy_blocks.append((r[0], 0, 1, 1))
			if r[4]:
			can_buy_strong_blocks.append(r[0])
			if r[3]:
			msg_list.append(r[3])
			if r[5]:
			active_buy_blocks.append(r[0])
			msg_list.append(f"【{r[0]}】激进买入({r[5]})")
			else:
			if r[3]:
			msg_list.append(r[3])
			# 所有板块都是独苗
			if unique_count == len(blocks_compute_results):
			return can_buy_blocks, True, ",".join(msg_list), can_buy_strong_blocks, keys
			return can_buy_blocks, False, ",".join(msg_list), can_buy_strong_blocks, keys
			return can_buy_blocks, True, ",".join(msg_list), can_buy_strong_blocks, keys, active_buy_blocks
			return can_buy_blocks, False, ",".join(msg_list), can_buy_strong_blocks, keys, active_buy_blocks

			# 更新代码板块判断是否可以买的结果
			# high_level_general_code_blocks 高位泛化板块
			@@ -799,15 +960,16 @@
			f_blocks.append(b)
			high_level_general_code_blocks[r[0]] = f_blocks

			can_buy_blocks, unique, msg, can_buy_strong_blocks, keys = cls.__compute_can_buy_blocks(code,
			current_limit_up_datas,
			limit_up_record_datas,
			yesterday_current_limit_up_codes,
			before_blocks_dict,
			current_limit_up_block_codes_dict,
			high_level_general_code_blocks)
			can_buy_blocks, unique, msg, can_buy_strong_blocks, keys, active_buy_blocks = cls.__compute_can_buy_blocks(code,
			current_limit_up_datas,
			limit_up_record_datas,
			yesterday_current_limit_up_codes,
			before_blocks_dict,
			current_limit_up_block_codes_dict,
			high_level_general_code_blocks)
			# 保存板块计算结果
			cls.__can_buy_compute_result_dict[code] = (can_buy_blocks, unique, msg, can_buy_strong_blocks, keys)
			cls.__can_buy_compute_result_dict[code] = (
			can_buy_blocks, unique, msg, can_buy_strong_blocks, keys, active_buy_blocks)


			if __name__ == "__main__":