# 开盘啦涨停数据管理
|
import json
|
import os
|
import threading
|
import time
|
|
from utils import tool
|
from kpl import kpl_util
|
from kpl import kpl_api
|
|
|
class KPLLimitUpDataManager:
|
__instance = None
|
limit_up_records_dict = {}
|
limit_up_current_dict = {}
|
__limit_up_history_datas_cache = {}
|
__limit_up_current_datas_cache = {}
|
|
def __new__(cls, *args, **kwargs):
|
if not cls.__instance:
|
cls.__instance = super(KPLLimitUpDataManager, cls).__new__(cls, *args, **kwargs)
|
cls.__load_data()
|
return cls.__instance
|
|
@classmethod
|
def __load_data(cls, day=tool.get_now_date_str()):
|
record_apth = cls.__get_record_path(day)
|
current_path = cls.__get_current_path(day)
|
limit_up_records_dict = {}
|
limit_up_current_dict = {}
|
|
# 获取历史涨停
|
if os.path.exists(record_apth):
|
children = os.listdir(record_apth)
|
for c in children:
|
with open(f"{record_apth}\\{c}", mode="r") as f:
|
line = f.readline().strip()
|
if line:
|
try:
|
data = json.loads(line)
|
limit_up_records_dict[data[0]] = data
|
except:
|
pass
|
|
# 获取实时涨停
|
if os.path.exists(current_path):
|
with open(current_path, mode="r") as f:
|
line = f.readline().strip()
|
if line:
|
try:
|
datas = json.loads(line)
|
for d in datas:
|
limit_up_current_dict[d[0]] = d
|
except:
|
pass
|
if day == tool.get_now_date_str():
|
cls.limit_up_records_dict = limit_up_records_dict
|
cls.limit_up_current_dict = limit_up_current_dict
|
return limit_up_records_dict, limit_up_current_dict
|
|
def __save_data(self, limit_up_datas):
|
record_path = self.__get_record_path()
|
current_path = self.__get_current_path()
|
if not os.path.exists(record_path):
|
os.makedirs(record_path)
|
for d in limit_up_datas:
|
code = d[0]
|
# 保存记录数据
|
with open(f"{record_path}\\{code}.log", mode='w') as f:
|
f.write(json.dumps(d))
|
|
with open(current_path, mode='w') as f:
|
f.write(json.dumps(limit_up_datas))
|
|
def add_data(self, limit_up_datas):
|
temp_limit_up_dict = {}
|
for d in limit_up_datas:
|
temp_limit_up_dict[d[0]] = d
|
self.limit_up_records_dict[d[0]] = d
|
self.limit_up_current_dict = temp_limit_up_dict
|
# 保存文件
|
threading.Thread(target=self.__save_data, args=(limit_up_datas,), daemon=True).start()
|
|
def get_limit_up_current_datas(self, day=tool.get_now_date_str()):
|
if day == tool.get_now_date_str():
|
temps = [self.limit_up_current_dict[k] for k in self.limit_up_current_dict]
|
else:
|
records, current = self.__load_data(day)
|
temps = [current[k] for k in current]
|
temps.sort(key=lambda x: x[2], reverse=True)
|
return temps
|
|
def get_limit_up_history_datas(self, day=tool.get_now_date_str()):
|
if day == tool.get_now_date_str():
|
temps = [self.limit_up_records_dict[k] for k in self.limit_up_records_dict]
|
else:
|
records, current = self.__load_data(day)
|
temps = [records[k] for k in records]
|
temps.sort(key=lambda x: x[2], reverse=True)
|
return temps
|
|
# 从缓存文件获取某天的涨停数据
|
def get_limit_up_current_datas_from_file(self, day):
|
current_path = self.__get_current_path(day)
|
# 获取实时涨停
|
if os.path.exists(current_path):
|
with open(current_path, mode="r") as f:
|
line = f.readline().strip()
|
if line:
|
datas = json.loads(line)
|
return datas
|
return None
|
|
# 从缓存文件获取某天的历史涨停数据
|
def get_limit_up_history_datas__from_file(self, day):
|
record_apth = self.__get_record_path(day)
|
if os.path.exists(record_apth):
|
fdatas = []
|
children = os.listdir(record_apth)
|
for c in children:
|
with open(f"{record_apth}\\{c}", mode="r") as f:
|
line = f.readline().strip()
|
if line:
|
data = json.loads(line)
|
fdatas.append(data)
|
return fdatas
|
return None
|
|
def get_limit_up_history_datas_cache(self, day):
|
if day not in self.__limit_up_history_datas_cache:
|
results = self.get_limit_up_history_datas__from_file(day)
|
if results:
|
self.__limit_up_history_datas_cache[day] = results
|
return self.__limit_up_history_datas_cache.get(day)
|
|
def get_limit_up_current_datas_cache(self, day):
|
if day not in self.__limit_up_current_datas_cache:
|
results = self.get_limit_up_current_datas_from_file(day)
|
if results:
|
self.__limit_up_current_datas_cache[day] = results
|
return self.__limit_up_current_datas_cache.get(day)
|
|
@classmethod
|
def __get_record_path(cls, day=None):
|
base_path = cls.__get_base_path(day)
|
return f"{base_path}\\record"
|
|
@classmethod
|
def __get_current_path(cls, day=None):
|
base_path = cls.__get_base_path(day)
|
return f"{base_path}\\limit_up.log"
|
|
@classmethod
|
def __get_base_path(cls, day=None):
|
if not day:
|
day = tool.get_now_date_str()
|
return f"{os.getcwd()}\\datas\\{day}"
|
|
def run(self):
|
while True:
|
try:
|
if not tool.is_trade_time(tool.get_now_time_str()):
|
continue
|
result = kpl_api.getLimitUpInfoNew()
|
limit_up_datas = kpl_util.parseLimitUpData(result)
|
KPLLimitUpDataManager().add_data(limit_up_datas)
|
except:
|
pass
|
finally:
|
time.sleep(3)
|
|
|
if __name__ == '__main__':
|
print(KPLLimitUpDataManager().get_limit_up_current_datas())
|
print(KPLLimitUpDataManager().get_limit_up_history_datas())
|
input()
|
