修改：意外实参，形参 'event_type' 未填，意外实参，形参 'event_type' 未填，意外实参，形参 'event_type' 未填，，意外实参，形参 'event_type' 未填，类 'FollowAnalysisModule' 的未解析的特性引用 '_submit_data'意外实参，形参 'event_type' 未填，类 'TrendAnalysisModule' 的未解析的特性引用 '_submit_data'，意外实参，形参 'event_type' 未填，类 'NumberGenerationModule' 的未解析的特性引用 '_submit_data'，意外实参，形参 'event_type' 未填，，意外实参，形参 'event_type' 未填，，意外实参，形参 'event_type' 未填，，意外实参，形参 'event_type' 未填，，意外实参，形参 'event_type' 未填，，意外实参，形参 'event_type' 未填，未解析的引用 'available_fronts'，未解析的引用 'available_backs'代码# ====== 号码池类 ======
class NumberPool:
def __init__(self):
self.data_store = {
'front_hot': [], 'back_hot': [], 'front_freq': {}, 'back_freq': {},
'front_missing': [], 'back_missing': [], 'recommendations': {},
'generated_numbers': [], 'frozen': False,
'front_numbers': [], 'back_numbers': [], 'special_data': {},
'organized_data': None
}
self.lock = threading.Lock()
self.current_module = None
self.module_status = {module: False for module in GlobalConfig.MODULES}
self.running = True
self._setup_subscriptions()
self._load_data()
def _setup_subscriptions(self):
"""设置事件订阅"""
event_center.subscribe(EventType.DATA_SUBMIT.value, self._handle_data_submit)
event_center.subscribe(EventType.MODULE_READY.value, self._handle_module_ready)
event_center.subscribe(EventType.MODULE_COMPLETE.value, self._handle_module_complete)
event_center.subscribe(EventType.DATA_FREEZE.value, self._handle_freeze)
event_center.subscribe(EventType.DATA_ORGANIZE.value, self._handle_organize)
event_center.subscribe(EventType.MODULE_RUN.value, self._handle_module_run)
event_center.subscribe(EventType.EXCLUDE_NUMBERS.value, self._handle_exclude_numbers)
def _handle_data_submit(self, event):
"""处理数据提交事件"""
if event.target == 'pool' and not self.data_store['frozen']:
with self.lock:
self.data_store.update(event.data or {})
self._save_data()
def _handle_exclude_numbers(self, event):
"""处理排除号码事件"""
if event.data:
exclude_front = event.data.get('exclude_front', '').split()
exclude_back = event.data.get('exclude_back', '').split()
self.data_store['excluded_front'] = [int(x) for x in exclude_front if x.isdigit()]
self.data_store['excluded_back'] = [int(x) for x in exclude_back if x.isdigit()]
logging.info(f"更新排除号码: 前区 {exclude_front}, 后区 {exclude_back}")
def _handle_module_ready(self, event):
"""处理模块就绪事件"""
if event.target == 'pool':
logging.info(f"模块 {event.source} 已就绪")
def _handle_module_complete(self, event):
"""处理模块完成事件"""
if event.target == 'pool':
logging.info(f"模块 {event.source} 已完成运行")
self.module_status[event.source] = False
self.current_module = None
def _handle_freeze(self, event):
"""处理数据冻结事件"""
if event.target == 'pool':
with self.lock:
self.data_store['frozen'] = True
logging.info("号码池数据已冻结")
def _handle_organize(self, event):
"""处理数据整理事件"""
if event.target == 'pool':
with self.lock:
self._organize_data()
logging.info("号码池数据已整理")
update_event = Event(
event_id=int(time.time()),
type=EventType.UI_UPDATE.value,
source='pool',
target='main_ui',
data={'update_type': 'organized_data', 'data': self.data_store['organized_data']}
)
event_center.publish(update_event)
def _organize_data(self):
"""整理号码池数据到核心展示区"""
organized = {
'front_numbers': self._organize_front_numbers(),
'back_numbers': self._organize_back_numbers(),
'front_hot': self._organize_front_hot(),
'front_cold': self._organize_front_cold(),
'back_hot': self._organize_back_hot(),
'back_cold': self._organize_back_cold()
}
self.data_store['organized_data'] = organized
return organized
def _organize_front_numbers(self):
"""整理前区号码"""
front_numbers = self.data_store.get('front_numbers', [])
uncombined = self.data_store.get('recommendations', {}).get('uncombined', [])
return sorted(list(set(front_numbers + uncombined)))
def _organize_back_numbers(self):
"""整理后区号码"""
return self.data_store.get('back_numbers', [])
def _organize_front_hot(self):
"""整理前区热号"""
front_freq = list(self.data_store.get('front_freq', {}).keys())
front_freq_rec = self.data_store.get('recommendations', {}).get('front_freq_50', [])
front_rec_more = self.data_store.get('recommendations', {}).get('front_rec_more', [])
hot_cold_rec = self.data_store.get('recommendations', {}).get('hot_cold_rec', {}).get('hot', [])
hot_numbers = list(set(
[int(x) for x in front_freq] +
front_freq_rec +
front_rec_more +
hot_cold_rec
))
return sorted(hot_numbers)
def _organize_front_cold(self):
"""整理前区冷号"""
front_missing = self.data_store.get('front_missing', [])
front_rec_less = self.data_store.get('recommendations', {}).get('front_rec_less', [])
hot_cold_rec = self.data_store.get('recommendations', {}).get('hot_cold_rec', {}).get('cold', [])
cold_numbers = list(set(
front_missing +
front_rec_less +
hot_cold_rec
))
return sorted(cold_numbers)
def _organize_back_hot(self):
"""整理后区热号"""
back_freq = list(self.data_store.get('back_freq', {}).keys())
back_rec_more = self.data_store.get('recommendations', {}).get('back_rec_more', [])
hot_rec = self.data_store.get('recommendations', {}).get('hot_rec', [])
hot_numbers = list(set(
[int(x) for x in back_freq] +
back_rec_more +
hot_rec
))
return sorted(hot_numbers)
def _organize_back_cold(self):
"""整理后区冷号"""
back_missing = self.data_store.get('back_missing', [])
back_infreq_rec = self.data_store.get('recommendations', {}).get('back_infreq_50', [])
back_rec_less = self.data_store.get('recommendations', {}).get('back_rec_less', [])
cold_rec = self.data_store.get('recommendations', {}).get('cold_rec', [])
cold_numbers = list(set(
back_missing +
back_infreq_rec +
back_rec_less +
cold_rec
))
return sorted(cold_numbers)
def _handle_module_run(self, event):
"""处理模块运行事件"""
if event.target == 'pool' and event.source in GlobalConfig.MODULES:
self.current_module = event.source
self.module_status[event.source] = True
logging.info(f"模块 {event.source} 开始运行")
run_event = Event(
event_id=int(time.time()),
type=EventType.MODULE_RUN.value,
source='pool',
target=event.source
)
event_center.publish(run_event)
def _save_data(self):
"""保存数据到文件"""
try:
with open(GlobalConfig.POOL_SAVE_PATH, 'w', encoding='utf-8') as f:
json.dump(self.data_store, f, ensure_ascii=False, indent=2)
except IOError as e:
logging.error(f"[号码池] 保存数据失败: {str(e)}")
def _load_data(self):
"""从文件加载数据"""
if os.path.exists(GlobalConfig.POOL_SAVE_PATH):
try:
with open(GlobalConfig.POOL_SAVE_PATH, 'r', encoding='utf-8') as f:
data = json.load(f)
with self.lock:
self.data_store.update(data)
logging.info("[号码池] 成功加载之前保存的数据")
except (IOError, json.JSONDecodeError) as e:
logging.error(f"[号码池] 加载数据失败: {str(e)}")
def update(self, label, value):
"""更新号码池数据"""
with self.lock:
label_mapping = {
"前区:": 'front_numbers',
"后区:": 'back_numbers',
"前数字频:": 'front_freq',
"前数字缺:": 'front_missing',
"后数字频:": 'back_freq',
"后数字缺:": 'back_missing',
"前频繁推:": 'front_freq_50',
"后低频推:": 'back_infreq_50',
"生组合数:": 'comb_count',
"未组合码:": 'uncombined',
"前推荐多:": 'front_rec_more',
"前推荐少:": 'front_rec_less',
"后推荐多:": 'back_rec_more',
"后推荐少:": 'back_rec_less',
"和值:": 'sum_rec',
"质合比:": 'prime_rec',
"奇偶比:": 'odd_even_rec',
"断区推荐:": 'zone_rec',
"连号推荐:": 'consec_rec',
"冷热推荐:": 'hot_cold_rec',
"后区热号:": 'hot_rec',
"后区冷号:": 'cold_rec',
"趋势号:": 'trend_rec'
}
if label in label_mapping:
self.data_store[label_mapping[label]] = value
self._save_data()
# ====== 基础模块类 ======
class BaseModule:
def __init__(self, module_name: str):
self.module_name = module_name
self._handlers = {}
self._setup_subscriptions()
self._initialize()
self.dynamic_data = {}
def _update_dynamic_data(self, data):
"""更新动态数据"""
self.dynamic_data.update(data)
def _update_ui(self):
"""更新UI（子类必须实现）"""
raise NotImplementedError("子类必须实现 _update_ui 方法")
def _setup_subscriptions(self):
"""设置事件订阅"""
event_center.subscribe(EventType.DATA_SUBMIT.value, self._handle_data_submit)
event_center.subscribe(EventType.MODULE_READY.value, self._handle_module_ready)
def _handle_data_submit(self, event):
"""默认数据提交处理器"""
pass
def _handle_module_ready(self, event):
"""默认模块就绪处理器"""
pass
def clear_dynamic_data(self):
"""清除动态数据"""
for key in self.dynamic_data:
if isinstance(self.dynamic_data[key], list):
self.dynamic_data[key] = []
elif isinstance(self.dynamic_data[key], dict):
self.dynamic_data[key] = {}
else:
self.dynamic_data[key] = ""
def save_dynamic_data(self, file_path):
"""保存动态数据到文件"""
with open(file_path, 'w') as f:
json.dump(self.dynamic_data, f)
def refresh_to_pool(self, number_pool):
"""刷新数据到号码池"""
for key, value in self.dynamic_data.items():
pool_label = f"{key}:" if not key.endswith(":") else key
number_pool.update(pool_label, value)
def _initialize(self):
"""初始化模块"""
ready_event = Event(
event_id=int(time.time()),
type=EventType.MODULE_READY.value, # 明确 event_type
source=self.module_name,
target='pool'
)
event_center.publish(ready_event)
def run(self):
"""运行模块"""
raise NotImplementedError("子类必须实现 run 方法")
def handle_event(self, event):
"""处理事件"""
handler = self._handlers.get(event.type)
if handler:
try:
handler(event)
except Exception as e:
logging.error(f"处理事件失败: {e}")
def register_handler(self, event_type, handler):
"""注册事件处理器"""
self._handlers[event_type] = handler
# ====== 输入分析模块 ======
class InputAnalysisModule(BaseModule):
def __init__(self, module_name: str, labels: list = None, master=None):
super().__init__(module_name)
self.master = master
self.labels = labels or [
"排除号码", "前区", "后区", "推荐号码",
"前区", "后区"
]
self._ui_callback = None
self._setup_event_handlers()
self.recommend_front_var = StringVar()
self.recommend_back_var = StringVar()
self.dynamic_data = {
"排除号码": {"前区": [], "后区": []},
"推荐号码": {"前区": [], "后区": []}
}
# 初始化排除号码输入框
self.exclude_front_entries = []
self.exclude_back_entries = []
self.dynamic_text = None
def _update_dynamic_data(self, data):
"""更新动态数据"""
self.dynamic_data.update(data)
def _update_ui(self):
"""更新UI"""
print(f"模块 {self.module_name} UI 更新完成")
def register_ui_callback(self, callback):
"""注册UI回调函数"""
if not callable(callback):
raise ValueError("回调函数必须是可调用对象")
self._ui_callback = callback
print(f"✅ 已注册UI回调函数: {callback.__name__}")
def _notify_ui(self, data):
"""通知UI更新"""
if self._ui_callback:
try:
self._ui_callback(data)
except Exception as e:
print(f"UI回调执行失败: {str(e)}")
@staticmethod
def _create_number_inputs(parent, count):
"""创建号码输入框"""
entries = []
frame = Frame(parent)
frame.pack(fill='x', padx=10, pady=2)
for i in range(count):
entry = Entry(frame, width=5)
entry.pack(side='left', padx=2)
entries.append(entry)
return entries
def _run_module(self):
"""发送运行指令"""
exclude_front = self._get_exclude_numbers(self.exclude_front_entries)
exclude_back = self._get_exclude_numbers(self.exclude_back_entries)
run_event = Event(
event_id=int(time.time()),
type=EventType.MODULE_RUN.value,
source=GlobalConfig.module1_id,
target='module1',
data={
"exclude_front": exclude_front,
"exclude_back": exclude_back
},
token=GlobalConfig.module1_id
)
event_center.publish(run_event)
logger.info(f"已发送运行指令到模块1 [Token: {GlobalConfig.module1_id}]")
@staticmethod
def _get_exclude_numbers(entries):
"""从输入框获取排除号码"""
numbers = []
for entry in entries:
val = entry.get().strip()
if val.isdigit():
num = int(val)
if 1 <= num <= 33:
numbers.append(num)
else:
logger.warning(f"无效号码输入: {num}")
return numbers
def _setup_event_handlers(self):
"""配置事件处理器"""
event_center.subscribe(
EventType.MODULE_RUN.value,
self._handle_run_event,
token=self.module_name
)
def _handle_run_event(self, event):
"""处理运行事件"""
if event.target != self.module_name:
return
print(f"模块 {self.module_name} 收到运行事件")
def _update_ui_with_result(self, result):
"""根据结果更新UI"""
if 'recommended_fronts' in result:
self.recommend_front_var.set(' '.join(map(str, result['recommended_fronts'])))
if 'recommended_backs' in result:
self.recommend_back_var.set(' '.join(map(str, result['recommended_backs'])))
def _update_dynamic_text(self, data):
"""更新动态文本"""
if not hasattr(self, 'dynamic_text') or self.dynamic_text is None:
logging.warning("未找到 dynamic_text 控件")
return
if data.get("token") == GlobalConfig.module1_id:
self.dynamic_text.insert('end', f"【{GlobalConfig.module1_id}】分析结果:\n")
self.dynamic_text.insert('end', f"前区排除: {data.get('exclude_front', [])}\n")
self.dynamic_text.insert('end', f"后区排除: {data.get('exclude_back', [])}\n\n")
self.dynamic_text.see('end')
def update_ui(self, data):
"""更新UI（供前端加载器调用）"""
if 'update_type' in data:
if data['update_type'] == 'input_data':
self._update_dynamic_data(data.get('data', {}))
self._update_ui()
# ====== 组合分析模块 ======
class CombinationAnalysisModule(BaseModule):
def __init__(self, module_name: str, labels: list = None, master=None):
super().__init__(module_name)
self.master = master
self.labels = labels or ["推荐号码"]
self.some_frame = None
self.dynamic_text = None
self.dynamic_data = {
"前数字频": {},
"前数字缺": [],
"后数字频": {},
"后数字缺": [],
"前频繁推": [],
"后低频推": [],
"生组合数": 0,
"未组合码": []
}
self._setup_result_handler()
self._create_ui()
def _setup_result_handler(self):
"""设置结果处理器"""
def handler(event):
if event.target == self.module_name and event.data.get("token") == GlobalConfig.module2_id:
self._update_dynamic_text(event.data)
event_center.subscribe(
EventType.ANALYSIS_RESULT.value,
handler,
token=GlobalConfig.module2_id
)
def _create_ui(self):
"""创建界面组件"""
self.some_frame = Frame(self.master)
self.some_frame.pack(fill='x', padx=10, pady=5)
label_text = self.labels[0] if len(self.labels) > 0 else "推荐号码"
Label(self.some_frame, text=label_text, font=("楷体", 14)).pack()
# 动态文本框
self.dynamic_text = Text(self.some_frame, height=10)
self.dynamic_text.pack(fill='both', padx=10, pady=5)
def _update_dynamic_text(self, result):
"""更新动态文本框内容"""
if hasattr(self, 'dynamic_text') and self.dynamic_text is not None:
self.dynamic_text.delete(1.0, 'end')
self.dynamic_text.insert('end', json.dumps(result, indent=2, ensure_ascii=False))
def _submit_data(self, data):
"""提交分析结果到号码池"""
logger.info(f"提交数据: {data}")
# ====== 跟随分析模块 ======
class FollowAnalysisModule(BaseModule):
def __init__(self, module_name: str):
super().__init__(module_name)
self.dynamic_data = {"follow_data": {}}
def _update_dynamic_data(self, data):
"""更新动态数据"""
self.dynamic_data.update(data)
def _update_ui(self):
"""更新UI"""
print(f"模块 {self.module_name} UI 更新完成")
def _handle_module_run(self, event):
"""处理模块运行事件"""
logger.info(f"跟随分析模块 {self.module_name} 开始运行")
front_rec_more = sorted(random.sample(range(1, 36), 5))
front_rec_less = sorted(random.sample(range(1, 36), 5))
back_rec_more = sorted(random.sample(range(1, 13), 2))
back_rec_less = sorted(random.sample(range(1, 13), 2))
self._submit_data({
"前推荐多": front_rec_more,
"前推荐少": front_rec_less,
"后推荐多": back_rec_more,
"后推荐少": back_rec_less
})
complete_event = Event(
event_id=int(time.time()),
type=EventType.MODULE_COMPLETE.value, # 明确 event_type
source=self.module_name,
target='pool'
)
event_center.publish(complete_event)
def update_ui(self, data):
"""更新UI（供前端加载器调用）"""
if 'update_type' in data and data['update_type'] == 'combination_data':
self._update_dynamic_data(data.get('data', {}))
self._update_ui()
# ====== 趋势分析模块 ======
class TrendAnalysisModule(BaseModule):
def __init__(self, module_name: str):
super().__init__(module_name)
self.dynamic_data = {"trend_data": {}}
def _update_dynamic_data(self, data):
"""更新动态数据"""
self.dynamic_data.update(data)
def _update_ui(self):
"""更新UI"""
print(f"模块 {self.module_name} UI 更新完成")
def _handle_module_run(self, event):
"""处理模块运行事件"""
logger.info(f"趋势分析模块 {self.module_name} 开始运行")
sum_value = random.randint(60, 125)
prime_ratio = f"{random.randint(1, 5)}:{random.randint(1, 5)}"
odd_even_ratio = f"{random.randint(1, 5)}:{random.randint(1, 5)}"
zone_rec = random.choice(["一区", "二区", "三区", "四区", "五区", "六区", "七区"])
consec_rec = random.sample(range(1, 36), 2)
hot_rec = sorted(random.sample(range(1, 13), 2))
cold_rec = sorted(random.sample(range(1, 13), 2))
trend_rec = sorted(random.sample(range(1, 36), 5))
self._submit_data({
"和值": sum_value,
"质合比": prime_ratio,
"奇偶比": odd_even_ratio,
"断区推荐": zone_rec,
"连号推荐": consec_rec,
"后区热号": hot_rec,
"后区冷号": cold_rec,
"趋势号": trend_rec
})
complete_event = Event(
event_id=int(time.time()),
type=EventType.MODULE_COMPLETE.value, # 明确 event_type
source=self.module_name,
target='pool'
)
event_center.publish(complete_event)
def update_ui(self, data):
"""更新UI（供前端加载器调用）"""
if 'update_type' in data and data['update_type'] == 'trend_data':
self._update_dynamic_data(data.get('data', {}))
self._update_ui()
# ====== 号码生成模块 ======
class NumberGenerationModule(BaseModule):
def __init__(self, module_name: str, labels: list = None):
super().__init__(module_name)
self.labels = labels or []
self.dynamic_data = {
"胆码": {
"前区": [],
"后区": []
},
"推荐5注号码": {
"1": "",
"2": "",
"3": "",
"4": "",
"5": ""
}
}
def _handle_module_run(self, event):
"""处理模块运行事件"""
logger.info(f"号码生成模块 {self.module_name} 运行")
# 生成号码组合
generated = []
for _ in range(5):
front = sorted(random.sample(range(1, 36), 5))
back = sorted(random.sample(range(1, 13), 2))
generated.append({"front": front, "back": back})
# 提交结果
self._submit_data({
"generated_numbers": generated
})
# 标记完成
complete_event = Event(
event_id=int(time.time()),
type=EventType.MODULE_COMPLETE.value,
source=self.module_name,
target='pool'
)
event_center.publish(complete_event)
def update_ui(self, data):
"""更新UI（供前端加载器调用）"""
if 'update_type' in data:
if data['update_type'] == 'generation_data':
self._update_dynamic_data(data.get('data', {}))
self._update_ui()
# ====== 对话框基类（抽象重复逻辑） ======
class ModuleDialogBase:
def __init__(self, parent, module_id):
self.parent = parent
self.module_id = module_id
self.create_dialog()
def create_dialog(self):
self.dialog = Toplevel()
self.dialog.title(f"{self.module_id} - 设置")
self.dialog.geometry("400x300")
self.dialog.resizable(False, False)
# ====== 对话框管理器 ======
class DialogManager:
def __init__(self):
self.dialogs = {}
self._setup_subscriptions()
def _setup_subscriptions(self):
"""设置事件订阅"""
event_center.subscribe(EventType.DIALOG_OPEN.value, self._handle_dialog_open)
event_center.subscribe(EventType.DIALOG_CLOSE.value, self._handle_dialog_close)
def _handle_dialog_open(self, event):
"""处理对话框打开事件"""
dialog_type = event.data.get('dialog_type')
if dialog_type and dialog_type not in self.dialogs:
self._create_dialog(dialog_type)
def _handle_dialog_close(self, event):
"""处理对话框关闭事件"""
dialog_type = event.data.get('dialog_type')
if dialog_type and dialog_type in self.dialogs:
self.dialogs[dialog_type].destroy()
del self.dialogs[dialog_type]
def _create_dialog(self, dialog_type):
"""创建对话框"""
dialog = Toplevel()
dialog.title(f"{dialog_type} - 设置")
dialog.geometry("400x300")
dialog.resizable(False, False)
# 根据对话框类型创建不同的内容
if dialog_type == GlobalConfig.module1_id:
self._create_input_analysis_dialog(dialog)
elif dialog_type == GlobalConfig.module2_id:
self._create_combination_analysis_dialog(dialog)
elif dialog_type == GlobalConfig.module3_id:
self._create_follow_analysis_dialog(dialog)
elif dialog_type == GlobalConfig.module4_id:
self._create_trend_analysis_dialog(dialog)
elif dialog_type == GlobalConfig.module5_id:
self._create_number_generation_dialog(dialog)
self.dialogs[dialog_type] = dialog
dialog.protocol("WM_DELETE_WINDOW", lambda: self._close_dialog(dialog_type))
def _create_input_analysis_dialog(self, parent):
"""创建输入分析对话框"""
main_frame = Frame(parent)
main_frame.pack(fill='both', expand=True, padx=10, pady=10)
# 排除号码区
exclude_frame = LabelFrame(main_frame, text="排除号码", font=('微软雅黑', 10))
exclude_frame.pack(fill='x', pady=5)
# 前区排除
Label(exclude_frame, text="前区排除:", font=('微软雅黑', 9)).pack(anchor='w')
front_frame = Frame(exclude_frame)
front_frame.pack(fill='x', pady=2)
self.front_exclude_vars = []
for i in range(10):
var = StringVar()
Entry(front_frame, textvariable=var, width=3).pack(side='left', padx=2)
self.front_exclude_vars.append(var)
# 后区排除
Label(exclude_frame, text="后区排除:", font=('微软雅黑', 9)).pack(anchor='w', pady=(10, 0))
back_frame = Frame(exclude_frame)
back_frame.pack(fill='x', pady=2)
self.back_exclude_vars = []
for i in range(10):
var = StringVar()
Entry(back_frame, textvariable=var, width=3).pack(side='left', padx=2)
self.back_exclude_vars.append(var)
# 推荐号码区
recommend_frame = LabelFrame(main_frame, text="推荐号码", font=('微软雅黑', 10))
recommend_frame.pack(fill='x', pady=5)
# 前区推荐
Label(recommend_frame, text="前区推荐:", font=('微软雅黑', 9)).pack(anchor='w')
self.front_recommend_var = StringVar()
Entry(recommend_frame, textvariable=self.front_recommend_var,
state='readonly', width=30).pack(fill='x', pady=2)
# 后区推荐
Label(recommend_frame, text="后区推荐:", font=('微软雅黑', 9)).pack(anchor='w', pady=(10, 0))
self.back_recommend_var = StringVar()
Entry(recommend_frame, textvariable=self.back_recommend_var,
state='readonly', width=30).pack(fill='x', pady=2)
# 按钮区
button_frame = Frame(main_frame)
button_frame.pack(fill='x', pady=10)
Button(button_frame, text="保存", command=self._save_input_settings).pack(side='right', padx=5)
Button(button_frame, text="取消", command=lambda: self._close_dialog(GlobalConfig.module1_id)).pack(
side='right', padx=5)
def _create_combination_analysis_dialog(self, parent):
"""创建组合分析对话框"""
main_frame = Frame(parent)
main_frame.pack(fill='both', expand=True, padx=10, pady=10)
# 结果显示区
result_frame = LabelFrame(main_frame, text="组合分析结果", font=('微软雅黑', 10))
result_frame.pack(fill='both', expand=True)
# 创建结果显示组件
labels = ["前数字频", "前数字缺", "后数字频", "后数字缺",
"前频繁推", "后低频推", "生组合数", "未组合码"]
self.combination_vars = {}
for i, label in enumerate(labels):
frame = Frame(result_frame)
frame.pack(fill='x', padx=5, pady=2)
Label(frame, text=f"{label}:", width=10, anchor='w').pack(side='left')
var = StringVar()
Entry(frame, textvariable=var, state='readonly', width=20).pack(side='left', fill='x', expand=True)
self.combination_vars[label] = var
# 按钮区
button_frame = Frame(main_frame)
button_frame.pack(fill='x', pady=10)
Button(button_frame, text="关闭", command=lambda: self._close_dialog(GlobalConfig.module2_id)).pack(
side='right', padx=5)
def _create_follow_analysis_dialog(self, parent):
"""创建跟随分析对话框"""
main_frame = Frame(parent)
main_frame.pack(fill='both', expand=True, padx=10, pady=10)
# 结果显示区
result_frame = LabelFrame(main_frame, text="跟随分析结果", font=('微软雅黑', 10))
result_frame.pack(fill='both', expand=True)
# 创建结果显示组件
labels = ["前推荐多", "前推荐少", "后推荐多", "后推荐少"]
self.follow_vars = {}
for i, label in enumerate(labels):
frame = Frame(result_frame)
frame.pack(fill='x', padx=5, pady=2)
Label(frame, text=f"{label}:", width=10, anchor='w').pack(side='left')
var = StringVar()
Entry(frame, textvariable=var, state='readonly', width=20).pack(side='left', fill='x', expand=True)
self.follow_vars[label] = var
# 按钮区
button_frame = Frame(main_frame)
button_frame.pack(fill='x', pady=10)
Button(button_frame, text="关闭", command=lambda: self._close_dialog(GlobalConfig.module3_id)).pack(
side='right', padx=5)
def _create_trend_analysis_dialog(self, parent):
"""创建趋势分析对话框"""
main_frame = Frame(parent)
main_frame.pack(fill='both', expand=True, padx=10, pady=10)
# 结果显示区
result_frame = LabelFrame(main_frame, text="趋势分析结果", font=('微软雅黑', 10))
result_frame.pack(fill='both', expand=True)
# 创建结果显示组件
labels = ["和值", "质合比", "奇偶比", "断区推荐", "连号推荐",
"后区热号", "后区冷号", "趋势号"]
self.trend_vars = {}
for i, label in enumerate(labels):
frame = Frame(result_frame)
frame.pack(fill='x', padx=5, pady=2)
Label(frame, text=f"{label}:", width=10, anchor='w').pack(side='left')
var = StringVar()
Entry(frame, textvariable=var, state='readonly', width=20).pack(side='left', fill='x', expand=True)
self.trend_vars[label] = var
# 按钮区
button_frame = Frame(main_frame)
button_frame.pack(fill='x', pady=10)
Button(button_frame, text="关闭", command=lambda: self._close_dialog(GlobalConfig.module4_id)).pack(
side='right', padx=5)
def _create_number_generation_dialog(self, parent):
"""创建数字生成对话框"""
main_frame = Frame(parent)
main_frame.pack(fill='both', expand=True, padx=10, pady=10)
# 胆码输入区
dan_frame = LabelFrame(main_frame, text="胆码", font=('微软雅黑', 10))
dan_frame.pack(fill='x', pady=5)
# 前区胆码
Label(dan_frame, text="前区胆码:", font=('微软雅黑', 9)).pack(anchor='w')
front_frame = Frame(dan_frame)
front_frame.pack(fill='x', pady=2)
self.front_dan_vars = []
for i in range(5):
var = StringVar()
Entry(front_frame, textvariable=var, width=3).pack(side='left', padx=2)
self.front_dan_vars.append(var)
# 后区胆码
Label(dan_frame, text="后区胆码:", font=('微软雅黑', 9)).pack(anchor='w', pady=(10, 0))
back_frame = Frame(dan_frame)
back_frame.pack(fill='x', pady=2)
self.back_dan_vars = []
for i in range(5):
var = StringVar()
Entry(back_frame, textvariable=var, width=3).pack(side='left', padx=2)
self.back_dan_vars.append(var)
# 推荐号码区
recommend_frame = LabelFrame(main_frame, text="推荐5注号码", font=('微软雅黑', 10))
recommend_frame.pack(fill='both', expand=True, pady=5)
self.recommend_vars = {}
for i in range(1, 6):
frame = Frame(recommend_frame)
frame.pack(fill='x', padx=5, pady=2)
Label(frame, text=f"第{i}注:", width=6, anchor='w').pack(side='left')
var = StringVar()
Entry(frame, textvariable=var, state='readonly', width=30).pack(side='left', fill='x', expand=True)
self.recommend_vars[str(i)] = var
# 按钮区
button_frame = Frame(main_frame)
button_frame.pack(fill='x', pady=10)
Button(button_frame, text="保存", command=self._save_generation_settings).pack(side='right', padx=5)
Button(button_frame, text="取消", command=lambda: self._close_dialog(GlobalConfig.module5_id)).pack(
side='right', padx=5)
def _save_input_settings(self):
"""保存输入分析设置"""
# 收集前区排除号码
front_exclude = []
for var in self.front_exclude_vars:
if var.get().strip():
try:
front_exclude.append(int(var.get()))
except ValueError:
pass
# 收集后区排除号码
back_exclude = []
for var in self.back_exclude_vars:
if var.get().strip():
try:
back_exclude.append(int(var.get()))
except ValueError:
pass
# 保存设置
settings = {
'exclude_front': front_exclude,
'exclude_back': back_exclude
}
# 发送保存事件
save_event = Event(
event_id=int(time.time()),
type=EventType.DATA_SUBMIT.value,
source='dialog_manager',
target=GlobalConfig.module1_id,
data=settings
)
event_center.publish(save_event)
messagebox.showinfo("提示", "输入分析设置已保存")
self._close_dialog(GlobalConfig.module1_id)
def _save_generation_settings(self):
"""保存数字生成设置"""
# 收集前区胆码
front_dan = []
for var in self.front_dan_vars:
if var.get().strip():
try:
front_dan.append(int(var.get()))
except ValueError:
pass
# 收集后区胆码
back_dan = []
for var in self.back_dan_vars:
if var.get().strip():
try:
back_dan.append(int(var.get()))
except ValueError:
pass
# 保存设置
settings = {
'front_dan': front_dan,
'back_dan': back_dan
}
# 发送保存事件
save_event = Event(
event_id=int(time.time()),
type=EventType.DATA_SUBMIT.value,
source='dialog_manager',
target=GlobalConfig.module5_id,
data=settings
)
event_center.publish(save_event)
messagebox.showinfo("提示", "数字生成设置已保存")
self._close_dialog(GlobalConfig.module5_id)
def _close_dialog(self, dialog_type):
"""关闭对话框"""
if dialog_type in self.dialogs:
close_event = Event(
event_id=int(time.time()),
type=EventType.DIALOG_CLOSE.value,
source='dialog_manager',
target='dialog_manager',
data={'dialog_type': dialog_type}
)
event_center.publish(close_event)
# ====== 应用上下文类 ======
class AppContext:
def __init__(self):
GlobalConfig.check_config()
self.modules_loaded = {module: False for module in GlobalConfig.MODULES}
self.modules_completed = {module: False for module in GlobalConfig.MODULES}
self.main_ui = None
self.dialog_manager = None
self.number_pool = NumberPool()
print("应用上下文初始化完成")
# 实例化全局上下文
app = AppContext()
# ==================== 输入分析引擎 ====================
class InputAnalysisEngine:
def __init__(self):
self.module_name = "input_analysis_engine"
self._setup_subscriptions()
logger.info("输入分析引擎已初始化")
def _setup_subscriptions(self):
"""设置事件订阅"""
event_center.subscribe(
EventType.MODULE_RUN.value,
self._handle_module_run,
token=self.module_name
)
def _handle_module_run(self, event):
"""处理模块运行事件"""
if event.target != self.module_name:
return
logger.info("输入分析引擎开始处理")
available_fronts = []
available_backs = []
try:
# 获取排除号码
exclude_front = event.data.get('exclude_front', [])
exclude_back = event.data.get('exclude_back', [])
# 生成前区可用号码 (1-35，排除指定号码)
all_fronts = list(range(1, 36))
available_fronts = [num for num in all_fronts if num not in exclude_front]
# 生成后区可用号码 (1-12，排除指定号码)
all_backs = list(range(1, 13))
available_backs = [num for num in all_backs if num not in exclude_back]
# 发布分析结果
result_event = Event(
event_id=int(time.time()),
type=EventType.ANALYSIS_RESULT.value, # 明确 event_type
source=self.module_name,
target='pool',
data={
"available_fronts": available_fronts,
"available_backs": available_backs,
"exclude_front": exclude_front,
"exclude_back": exclude_back
},
token=self.module_name
)
event_center.publish(result_event)
logger.info("输入分析结果已发布")
except Exception as e:
logger.error(f"输入分析失败: {str(e)}")
error_event = Event(
event_id=int(time.time()),
type=EventType.ERROR.value, # 明确 event_type
source=self.module_name,
target='pool',
data={"error": str(e)},
token=self.module_name
)
event_center.publish(error_event)
ui_update_event = Event(
event_id=int(time.time()),
type=EventType.UI_UPDATE.value, # 明确 event_type
source=self.module_name,
target='frontend_loader',
data={
'update_type': 'input_data',
'data': {
"available_fronts": available_fronts,
"available_backs": available_backs
}
},
token=GlobalConfig.module1_id # 指定目标模块
)
event_center.publish(ui_update_event)
# ====== 组合分析引擎 ======
class CombinationAnalysisEngine:
def __init__(self):
self._setup_subscriptions()
logger.info("组合分析引擎已初始化")
def _setup_subscriptions(self):
event_center.subscribe(
EventType.MODULE_RUN.value,
self._handle_module_run,
token=GlobalConfig.module2_id
)
def _handle_module_run(self, event):
logger.info("组合分析引擎开始处理")
# 模拟分析逻辑
front_freq = {i: random.randint(1, 100) for i in range(1, 36)}
front_missing = random.sample(range(1, 36), 5)
back_freq = {i: random.randint(1, 50) for i in range(1, 13)}
back_missing = random.sample(range(1, 13), 2)
front_freq_rec = sorted(random.sample(range(1, 36), 5))
back_infreq_rec = sorted(random.sample(range(1, 13), 2))
comb_count = random.randint(100, 1000)
uncombined = random.sample(range(1, 36), 5)
# 发布分析结果
result_event = Event(
event_id=int(time.time()),
type=EventType.ANALYSIS_RESULT.value,
source=GlobalConfig.module2_id,
target='pool',
data={
"前数字频": front_freq,
"前数字缺": front_missing,
"后数字频": back_freq,
"后数字缺": back_missing,
"前频繁推": front_freq_rec,
"后低频推": back_infreq_rec,
"生组合数": comb_count,
"未组合码": uncombined
},
token=GlobalConfig.module2_id
)
event_center.publish(result_event)
logger.info("组合分析结果已发布")
ui_update_event = Event(
event_id=int(time.time()),
type=EventType.UI_UPDATE.value,
source=self.module_name,
target='frontend_loader',
data={
'update_type': 'input_data',
'data': {
"available_fronts": available_fronts,
"available_backs": available_backs
}
},
token=GlobalConfig.module1_id # 指定目标模块
)
event_center.publish(ui_update_event)
最新发布
本文介绍如何通过配置xdebug扩展来优化PHP中var_dump函数的输出结果，使其能够更清晰地展示复杂数组结构。
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
