| | |
|---|
| | | import base64 |
|---|
| | | import http |
|---|
| | | import json |
|---|
| | | import logging |
|---|
| | | import socketserver |
|---|
| | | import time |
|---|
| | | from http.server import BaseHTTPRequestHandler |
|---|
| | | import cv2 |
|---|
| | | import dask |
|---|
| | | |
|---|
| | | import global_util |
|---|
| | | import gpcode_manager |
|---|
| | | import log |
|---|
| | | import tool |
|---|
| | | from l2 import code_price_manager |
|---|
| | | from utils import global_util, tool |
|---|
| | | from code_attribute import gpcode_manager |
|---|
| | | from log_module import log, log_analyse, log_export |
|---|
| | | from l2 import code_price_manager, l2_data_util |
|---|
| | | from l2.cancel_buy_strategy import HourCancelBigNumComputer |
|---|
| | | from output.limit_up_data_filter import IgnoreCodeManager |
|---|
| | | from third_data import kpl_util, kpl_data_manager, kpl_api |
|---|
| | | from third_data.code_plate_key_manager import RealTimeKplMarketData |
|---|
| | | from third_data.kpl_data_manager import KPLDataManager, KPLLimitUpDataRecordManager, KPLPlatManager, \ |
|---|
| | | from third_data.code_plate_key_manager import RealTimeKplMarketData, KPLPlateForbiddenManager |
|---|
| | | from third_data.history_k_data_util import HistoryKDatasUtils |
|---|
| | | from third_data.kpl_data_manager import KPLDataManager, KPLLimitUpDataRecordManager, \ |
|---|
| | | KPLCodeLimitUpReasonManager |
|---|
| | | from third_data.kpl_util import KPLDataType |
|---|
| | | from third_data.kpl_util import KPLDataType, KPLPlatManager |
|---|
| | | import urllib.parse as urlparse |
|---|
| | | from urllib.parse import parse_qs |
|---|
| | | from output import code_info_output, limit_up_data_filter, output_util |
|---|
| | | from output import code_info_output, limit_up_data_filter, output_util, kp_client_msg_manager |
|---|
| | | |
|---|
| | | from trade import bidding_money_manager, trade_manager |
|---|
| | | from trade.l2_trade_util import BlackListCodeManager |
|---|
| | |
|---|
| | | __IgnoreCodeManager = IgnoreCodeManager() |
|---|
| | | __KPLPlatManager = KPLPlatManager() |
|---|
| | | __KPLCodeLimitUpReasonManager = KPLCodeLimitUpReasonManager() |
|---|
| | | __KPLPlateForbiddenManager = KPLPlateForbiddenManager() |
|---|
| | | # 历史板块 |
|---|
| | | __history_plates_dict = {} |
|---|
| | | # 板块 |
|---|
| | | __blocks_dict = {} |
|---|
| | | # 精选,行业数据缓存 |
|---|
| | | __jingxuan_cache_dict = {} |
|---|
| | | __industry_cache_dict = {} |
|---|
| | | |
|---|
| | | |
|---|
| | | def __get_limit_up_list(self): |
|---|
| | | # 统计目前为止的代码涨停数量（分涨停原因） |
|---|
| | | now_limit_up_codes_info = self.__kplDataManager.get_data(KPLDataType.LIMIT_UP) |
|---|
| | | limit_up_reason_dict = {} |
|---|
| | | for d in now_limit_up_codes_info: |
|---|
| | | if d[5] not in limit_up_reason_dict: |
|---|
| | | limit_up_reason_dict[d[5]] = [0, 0] |
|---|
| | | limit_up_reason_dict[d[5]][0] += 1 |
|---|
| | | # 获取想买原因想买单的代码数量 |
|---|
| | | reason_map = self.__KPLCodeLimitUpReasonManager.list_all() |
|---|
| | | want_codes = gpcode_manager.WantBuyCodesManager.list_code() |
|---|
| | | # 其他想买单 |
|---|
| | | other_count = 0 |
|---|
| | | for k in reason_map: |
|---|
| | | reson = reason_map[k] |
|---|
| | | if k in want_codes and reson in limit_up_reason_dict: |
|---|
| | | limit_up_reason_dict[reson][1] += 1 |
|---|
| | | elif k in want_codes: |
|---|
| | | other_count += 1 |
|---|
| | | |
|---|
| | | limit_up_reason_statistic_info = [(k, limit_up_reason_dict[k][0], limit_up_reason_dict[k][1]) for k in |
|---|
| | | limit_up_reason_dict] |
|---|
| | | limit_up_reason_statistic_info.sort(key=lambda x: x[1]) |
|---|
| | | limit_up_reason_statistic_info.reverse() |
|---|
| | | if other_count > 0: |
|---|
| | | limit_up_reason_statistic_info.insert(0, ('其他', other_count, other_count)) |
|---|
| | | |
|---|
| | | total_datas = KPLLimitUpDataRecordManager.total_datas |
|---|
| | | if not total_datas: |
|---|
| | | KPLLimitUpDataRecordManager.load_total_datas() |
|---|
| | | total_datas = KPLLimitUpDataRecordManager.total_datas |
|---|
| | | # 通过涨停时间排序 |
|---|
| | | total_datas = list(total_datas) |
|---|
| | | |
|---|
| | | # 统计涨停原因 |
|---|
| | | limit_up_reason_dict = {} |
|---|
| | | for d in total_datas: |
|---|
| | | if d[2] not in limit_up_reason_dict: |
|---|
| | | limit_up_reason_dict[d[2]] = [] |
|---|
| | | limit_up_reason_dict[d[2]].append(d) |
|---|
| | | for k in limit_up_reason_dict: |
|---|
| | | limit_up_reason_dict[k].sort(key=lambda x: int(x[5])) |
|---|
| | | # 统计想买单数量 |
|---|
| | | want_codes = gpcode_manager.WantBuyCodesManager().list_code_cache() |
|---|
| | | limit_up_reason_want_count_dict = {} |
|---|
| | | for d in total_datas: |
|---|
| | | if d[2] not in limit_up_reason_want_count_dict: |
|---|
| | | limit_up_reason_want_count_dict[d[2]] = 0 |
|---|
| | | if d[3] in want_codes: |
|---|
| | | limit_up_reason_want_count_dict[d[2]] += 1 |
|---|
| | | # (板块名称，涨停代码数量，想买单数量,涨停时间) |
|---|
| | | limit_up_reason_statistic_info = [ |
|---|
| | | (k, len(limit_up_reason_dict[k]), limit_up_reason_want_count_dict.get(k), limit_up_reason_dict[k][0][5]) for |
|---|
| | | k in |
|---|
| | | limit_up_reason_dict] |
|---|
| | | limit_up_reason_statistic_info.sort(key=lambda x: int(x[3])) |
|---|
| | | |
|---|
| | | codes_set = set([d[3] for d in total_datas]) |
|---|
| | | # 判断是龙几，判断是否涨停，判断是否炸板，加载分数 |
|---|
| | |
|---|
| | | total_datas.reverse() |
|---|
| | | |
|---|
| | | # 获取涨停原因变化记录 |
|---|
| | | reason_changes = log.load_kpl_reason_changes() |
|---|
| | | reason_changes = log_export.load_kpl_reason_changes() |
|---|
| | | reason_changes.reverse() |
|---|
| | | reason_changes_dict = {} |
|---|
| | | for r in reason_changes: |
|---|
| | | if r[0] not in reason_changes_dict: |
|---|
| | | reason_changes_dict[r[0]] = r[1] |
|---|
| | | # 统计最近下单动作反馈 |
|---|
| | | order_reasons_dict = log_analyse.get_cant_order_reasons_dict() |
|---|
| | | kpl_can_buy_reasons_dict = log_analyse.get_kpl_can_buy_reasons_dict() |
|---|
| | | |
|---|
| | | for d in total_datas: |
|---|
| | | code = d[3] |
|---|
| | | # (代码, 名称, 涨停状态(0 - 无状态 1-涨停 2-炸板), 龙几, 首板, 分值, 涨停时间, 原因, 相同原因代码数量, 自由流通, 涨停原因是否变化) |
|---|
| | | # (代码, 名称, 涨停状态(0 - 无状态 1-涨停 2-炸板), 龙几, 首板, 分值, 涨停时间, 原因, 相同原因代码数量, 自由流通, 涨停原因是否变化,涨停原因的流入净额,下单简介) |
|---|
| | | limit_up_state = 0 |
|---|
| | | if code in limit_up_dict: |
|---|
| | | if limit_up_dict[code][0]: |
|---|
| | |
|---|
| | | score = score_dict[code] |
|---|
| | | if code in ignore_codes: |
|---|
| | | continue |
|---|
| | | |
|---|
| | | # 涨停原因的净流入金额 |
|---|
| | | reason = d[2] |
|---|
| | | reason_money = '' |
|---|
| | | if reason in self.__jingxuan_cache_dict: |
|---|
| | | reason_money = output_util.money_desc(self.__jingxuan_cache_dict[reason][3]) |
|---|
| | | elif reason in self.__industry_cache_dict: |
|---|
| | | reason_money = output_util.money_desc(self.__industry_cache_dict[reason][3]) |
|---|
| | | |
|---|
| | | # 匹配下单反馈 |
|---|
| | | order_desc = '' |
|---|
| | | order_reason = order_reasons_dict.get(code) |
|---|
| | | kpl_can_buy_reason = kpl_can_buy_reasons_dict.get(code) |
|---|
| | | if order_reason and kpl_can_buy_reason: |
|---|
| | | if int(order_reason[0].replace(":", "").replace(".", "")) > int( |
|---|
| | | kpl_can_buy_reason[0].replace(":", "").replace(".", "")): |
|---|
| | | order_desc = f"不：{order_reason[1]}" |
|---|
| | | else: |
|---|
| | | order_desc = f"买：{kpl_can_buy_reason[1]}" |
|---|
| | | elif order_reason: |
|---|
| | | order_desc = f"不：{order_reason[1]}" |
|---|
| | | elif kpl_can_buy_reason: |
|---|
| | | order_desc = f"买：{kpl_can_buy_reason[1]}" |
|---|
| | | |
|---|
| | | fresult.append((code, d[4], limit_up_state, f"龙{rank_dict.get(code)}", d[12], score, |
|---|
| | | output_util.time_format(int(d[5])), d[2], d[10], output_util.money_desc(d[13]), |
|---|
| | | reason_changes_dict.get(code))) |
|---|
| | | reason_changes_dict.get(code), reason_money, order_desc)) |
|---|
| | | response_data = json.dumps({"code": 0, "data": {"limit_up_count": len(limit_up_codes), |
|---|
| | | "open_limit_up_count": len(open_limit_up_codes), |
|---|
| | | "limit_up_reason_statistic": limit_up_reason_statistic_info, |
|---|
| | |
|---|
| | | codes_set = set([d[0] for d in temps]) |
|---|
| | | limit_up_dict, limit_up_codes, open_limit_up_codes = limit_up_data_filter.get_limit_up_info(codes_set) |
|---|
| | | score_dict = limit_up_data_filter.get_codes_scores_dict(codes_set) |
|---|
| | | want_codes = gpcode_manager.WantBuyCodesManager.list_code() |
|---|
| | | black_codes = BlackListCodeManager.list_codes() |
|---|
| | | want_codes = gpcode_manager.WantBuyCodesManager().list_code_cache() |
|---|
| | | black_codes = BlackListCodeManager().list_codes() |
|---|
| | | total_datas = KPLLimitUpDataRecordManager.total_datas |
|---|
| | | code_info_dict = {} |
|---|
| | | for val in total_datas: |
|---|
| | |
|---|
| | | response_data = "" |
|---|
| | | if url.path == "/get_kpl_data": |
|---|
| | | best_feng_kou = self.__kplDataManager.get_data(kpl_util.KPLDataType.BEST_FENG_KOU) |
|---|
| | | if not best_feng_kou: |
|---|
| | | best_feng_kou = [] |
|---|
| | | best_feng_kou = best_feng_kou[:22] |
|---|
| | | feng_kou = self.__kplDataManager.get_data(kpl_util.KPLDataType.FENG_KOU) |
|---|
| | | if not feng_kou: |
|---|
| | | feng_kou = [] |
|---|
| | | feng_kou = feng_kou[:22] |
|---|
| | | industry_rank = self.__kplDataManager.get_data(kpl_util.KPLDataType.INDUSTRY_RANK) |
|---|
| | | if not industry_rank: |
|---|
| | | industry_rank = [] |
|---|
| | | industry_rank = industry_rank[:22] |
|---|
| | | feng_xiang = self.__kplDataManager.get_data(kpl_util.KPLDataType.FENG_XIANG) |
|---|
| | | if not feng_xiang: |
|---|
| | | feng_xiang = [] |
|---|
| | | feng_xiang = feng_xiang[:22] |
|---|
| | | response_data = json.dumps({"code": 0, "data": {"best_feng_kou": best_feng_kou, "feng_kou": feng_kou, |
|---|
| | | "industry_rank": industry_rank, "feng_xiang": feng_xiang}}) |
|---|
| | | elif url.path == "/get_score_info": |
|---|
| | | start_time = time.time() |
|---|
| | | ps_dict = dict([(k, v[0]) for k, v in parse_qs(url.query).items()]) |
|---|
| | | code = ps_dict['code'] |
|---|
| | | name = ps_dict.get('name') |
|---|
| | | |
|---|
| | | data = code_info_output.get_output_params(code) |
|---|
| | | data = code_info_output.get_output_params(code, self.__jingxuan_cache_dict, self.__industry_cache_dict) |
|---|
| | | if data["code_name"].find("None") > -1 and name: |
|---|
| | | data["code_name"] = f"{name} {code}" |
|---|
| | | |
|---|
| | | self.__history_plates_dict[code] = (time.time(), data["kpl_code_info"]["code_records"]) |
|---|
| | | self.__blocks_dict[code] = (time.time(), data["kpl_code_info"]["plate"]) |
|---|
| | | if "plate" in data["kpl_code_info"]: |
|---|
| | | self.__blocks_dict[code] = (time.time(), data["kpl_code_info"]["plate"]) |
|---|
| | | |
|---|
| | | response_data = json.dumps({"code": 0, "data": data}) |
|---|
| | | print("get_score_info 耗时：", time.time() - start_time) |
|---|
| | | |
|---|
| | | # 获取评分信息 |
|---|
| | | pass |
|---|
| | | elif url.path == "/kpl/get_limit_up_list": |
|---|
| | |
|---|
| | | # 精选，主力净额顺序 |
|---|
| | | result = kpl_api.getMarketJingXuanRealRankingInfo(False) |
|---|
| | | result = kpl_util.parseMarketJingXuan(result) |
|---|
| | | |
|---|
| | | response_data = json.dumps({"code": 0, "data": result}) |
|---|
| | | forbidden_plates = self.__KPLPlateForbiddenManager.list_all() |
|---|
| | | fresult = [] |
|---|
| | | for d in result: |
|---|
| | | if type_ == 2 or type_ == 3: |
|---|
| | | self.__jingxuan_cache_dict[d[1]] = d |
|---|
| | | elif type_ == 0 or type_ == 1: |
|---|
| | | self.__industry_cache_dict[d[1]] = d |
|---|
| | | d = list(d) |
|---|
| | | d.append(1 if d[1] in forbidden_plates else 0) |
|---|
| | | fresult.append(d) |
|---|
| | | response_data = json.dumps({"code": 0, "data": fresult}) |
|---|
| | | elif url.path == "/kpl/add_ignore_code": |
|---|
| | | ps_dict = dict([(k, v[0]) for k, v in parse_qs(url.query).items()]) |
|---|
| | | code = ps_dict['code'] |
|---|
| | | type_ = ps_dict['type'] |
|---|
| | | self.__IgnoreCodeManager.ignore_code(type_, code) |
|---|
| | | response_data = json.dumps({"code": 0}) |
|---|
| | | elif url.path == "/kpl/forbidden_plate": |
|---|
| | | ps_dict = dict([(k, v[0]) for k, v in parse_qs(url.query).items()]) |
|---|
| | | plate = ps_dict["plate"] |
|---|
| | | # 加入禁止 |
|---|
| | | self.__KPLPlateForbiddenManager.save_plate(plate) |
|---|
| | | response_data = json.dumps({"code": 0}) |
|---|
| | | elif url.path == "/kpl/get_plate_codes": |
|---|
| | | # 获取涨停原因下面的代码 |
|---|
| | | ps_dict = dict([(k, v[0]) for k, v in parse_qs(url.query).items()]) |
|---|
| | | plate = ps_dict["plate"] |
|---|
| | | # 获取板块下的代码 |
|---|
| | | # 统计目前为止的代码涨停数量（分涨停原因） |
|---|
| | | now_limit_up_codes_info = self.__kplDataManager.get_data(KPLDataType.LIMIT_UP) |
|---|
| | | now_limit_up_codes = set([d[0] for d in now_limit_up_codes_info]) |
|---|
| | | # 获取历史涨停 |
|---|
| | | record_limit_up_datas = KPLLimitUpDataRecordManager.total_datas |
|---|
| | | if not record_limit_up_datas: |
|---|
| | | KPLLimitUpDataRecordManager.load_total_datas() |
|---|
| | | record_limit_up_datas = KPLLimitUpDataRecordManager.total_datas |
|---|
| | | |
|---|
| | | codes_info = [] |
|---|
| | | for d in record_limit_up_datas: |
|---|
| | | if d[2] != plate: |
|---|
| | | continue |
|---|
| | | # 代码,名称,涨停时间,是否炸板,是否想买,是否已经下过单 |
|---|
| | | codes_info.append( |
|---|
| | | [d[3], d[4], tool.to_time_str(int(d[5])), 1 if d[3] not in now_limit_up_codes else 0, 0, 0]) |
|---|
| | | codes_info.sort(key=lambda x: x[2]) |
|---|
| | | # 查询是否为想买单 |
|---|
| | | want_codes = gpcode_manager.WantBuyCodesManager().list_code_cache() |
|---|
| | | for code_info in codes_info: |
|---|
| | | code_info[4] = 1 if code_info[0] in want_codes else 0 |
|---|
| | | # 获取代码状态 |
|---|
| | | if trade_manager.CodesTradeStateManager().get_trade_state_cache(code_info[0]) != trade_manager.TRADE_STATE_NOT_TRADE: |
|---|
| | | code_info[5] = 1 |
|---|
| | | |
|---|
| | | response_data = json.dumps({"code": 0, "data": codes_info}) |
|---|
| | | elif url.path == "/get_h_cancel_data": |
|---|
| | | ps_dict = dict([(k, v[0]) for k, v in parse_qs(url.query).items()]) |
|---|
| | | code = ps_dict["code"] |
|---|
| | | if code: |
|---|
| | | total_datas = l2_data_util.local_today_datas.get(code) |
|---|
| | | if total_datas is None: |
|---|
| | | l2_data_util.load_l2_data(code) |
|---|
| | | total_datas = l2_data_util.local_today_datas.get(code) |
|---|
| | | |
|---|
| | | trade_state = trade_manager.CodesTradeStateManager().get_trade_state_cache(code) |
|---|
| | | if trade_state == trade_manager.TRADE_STATE_BUY_PLACE_ORDER or trade_state == trade_manager.TRADE_STATE_BUY_DELEGATED or trade_state == trade_manager.TRADE_STATE_BUY_SUCCESS: |
|---|
| | | hcancel_datas_dict, cancel_indexes_set = HourCancelBigNumComputer().get_watch_index_dict(code) |
|---|
| | | # 根据日志读取实时的计算数据 |
|---|
| | | h_cancel_latest_compute_info = log_export.get_h_cancel_compute_info(code) |
|---|
| | | if hcancel_datas_dict: |
|---|
| | | temp_list = [(k, hcancel_datas_dict[k][0]) for k in hcancel_datas_dict] |
|---|
| | | canceled_indexs = set([int(k.split("-")[0]) for k in cancel_indexes_set]) |
|---|
| | | temp_list.sort(key=lambda x: x[0]) |
|---|
| | | fdata = { |
|---|
| | | "computed_info": list( |
|---|
| | | h_cancel_latest_compute_info) if h_cancel_latest_compute_info else None, |
|---|
| | | "datas": []} |
|---|
| | | for i in range(0, len(temp_list)): |
|---|
| | | temp = temp_list[i] |
|---|
| | | val = total_datas[temp[0]]["val"] |
|---|
| | | canceled = temp[0] in canceled_indexs |
|---|
| | | fdata["datas"].append( |
|---|
| | | (val["time"], val["num"], |
|---|
| | | code_info_output.money_desc(val["num"] * float(val["price"]) * 100), |
|---|
| | | (1 if canceled else 0))) |
|---|
| | | response_data = json.dumps({"code": 0, "data": fdata}) |
|---|
| | | else: |
|---|
| | | response_data = json.dumps({"code": 1, "msg": "无H撤数据"}) |
|---|
| | | else: |
|---|
| | | response_data = json.dumps({"code": 1, "msg": "无H撤数据"}) |
|---|
| | | else: |
|---|
| | | response_data = json.dumps({"code": 1, "msg": "请上传code"}) |
|---|
| | | |
|---|
| | | elif url.path == "/get_last_trade_day_reasons": |
|---|
| | | # 获取上个交易日的相同涨停原因的代码信息 |
|---|
| | | ps_dict = dict([(k, v[0]) for k, v in parse_qs(url.query).items()]) |
|---|
| | | code = ps_dict["code"] |
|---|
| | | day = HistoryKDatasUtils.get_previous_trading_date(tool.get_now_date_str()) |
|---|
| | | # 获取涨停数据 |
|---|
| | | |
|---|
| | | # 获取代码的原因 |
|---|
| | | reasons = kpl_data_manager.KPLLimitUpDataRecordManager.list_by_code(code, day) |
|---|
| | | if reasons: |
|---|
| | | reasons = list(reasons) |
|---|
| | | reasons.sort(key=lambda x: x[9]) |
|---|
| | | reason = reasons[-1][2] |
|---|
| | | datas = self.__kplDataManager.get_from_file(kpl_util.KPLDataType.LIMIT_UP, day) |
|---|
| | | # (代码,名称,首次涨停时间,最近涨停时间,几板,涨停原因,板块,实际流通,主力净额,涨停原因代码,涨停原因代码数量) |
|---|
| | | result_list = [] |
|---|
| | | if datas: |
|---|
| | | for d in datas: |
|---|
| | | if d[5] == reason and d[0] != code: |
|---|
| | | # (代码,名称) |
|---|
| | | result_list.append((d[0], d[1])) |
|---|
| | | response_data = json.dumps({"code": 0, "data": {"reason": reason, "data": result_list}}) |
|---|
| | | else: |
|---|
| | | response_data = json.dumps({"code": 1, "msg": "昨日未涨停"}) |
|---|
| | | |
|---|
| | | elif url.path == "/pull_kp_client_msg": |
|---|
| | | # 拉取客户端消息 |
|---|
| | | ps_dict = dict([(k, v[0]) for k, v in parse_qs(url.query).items()]) |
|---|
| | | client = ps_dict["client"] |
|---|
| | | msg = kp_client_msg_manager.read_msg(client) |
|---|
| | | if msg: |
|---|
| | | response_data = json.dumps({"code": 0, "data": msg}) |
|---|
| | | else: |
|---|
| | | response_data = json.dumps({"code": 1, "msg": "暂无消息"}) |
|---|
| | | elif url.path == "/list_kp_client_msg": |
|---|
| | | msg_list = kp_client_msg_manager.list_msg_from_local() |
|---|
| | | msg_list.reverse() |
|---|
| | | msg_list = [f"{msg.split('|')[0]}{msg.split('|')[-1].split('-')[1].strip()}" for msg in msg_list] |
|---|
| | | response_data = json.dumps({"code": 0, "data": msg_list}) |
|---|
| | | |
|---|
| | | self.send_response(200) |
|---|
| | | # 发给请求客户端的响应数据 |
|---|
| | |
|---|
| | | code = d[0] |
|---|
| | | if code.find("00") == 0 or code.find("60") == 0: |
|---|
| | | limit_up_time = time.strftime("%H:%M:%S", time.localtime(d[2])) |
|---|
| | | code_price_manager.Buy1PriceManager.set_limit_up_time(code, limit_up_time) |
|---|
| | | code_price_manager.Buy1PriceManager().set_limit_up_time(code, limit_up_time) |
|---|
| | | self.__kplDataManager.save_data(type_, result_list) |
|---|
| | | kpl_data_manager.KPLLimitUpDataRecordManager.save_record(tool.get_now_date_str(), result_list) |
|---|
| | | elif type_ == KPLDataType.OPEN_LIMIT_UP.value: |
|---|
| | |
|---|
| | | return params |
|---|
| | | |
|---|
| | | |
|---|
| | | class ThreadedHTTPServer(socketserver.ThreadingMixIn, http.server.HTTPServer): |
|---|
| | | pass |
|---|
| | | |
|---|
| | | |
|---|
| | | def run(addr, port): |
|---|
| | | # 运行看盘消息采集 |
|---|
| | | # kp_client_msg_manager.run_capture() |
|---|
| | | kpl_data_manager.run_pull_task() |
|---|
| | | |
|---|
| | | handler = DataServer |
|---|
| | | httpd = socketserver.TCPServer((addr, port), handler) |
|---|
| | | # httpd = socketserver.TCPServer((addr, port), handler) |
|---|
| | | httpd = ThreadedHTTPServer((addr, port), handler) |
|---|
| | | print("HTTP server is at: http://%s:%d/" % (addr, port)) |
|---|
| | | httpd.serve_forever() |
|---|
| | | |
|---|
