1

sync/account_sync.py

@@ -14,8 +14,14 @@ class AccountSyncBatch(BaseSync):
         """批量同步所有账号的账户信息"""
         try:
             logger.info(f"开始批量同步账户信息，共 {len(accounts)} 个账号")
+
+            # 测试
+            # res = await self.redis_client._get_account_info_from_redis(10140, 5548, 'mt5')
+            # print(res)
+            # return
             # 收集所有账号的数据
-            all_account_data = await self._collect_all_account_data(accounts)
+            all_account_data = await self.redis_client._collect_all_account_data(accounts)
+            
             
             if not all_account_data:
                 logger.info("无账户信息数据需要同步")
@@ -32,187 +38,8 @@ class AccountSyncBatch(BaseSync):
         except Exception as e:
             logger.error(f"账户信息批量同步失败: {e}")
     
-    async def _collect_all_account_data(self, accounts: Dict[str, Dict]) -> List[Dict]:
-        """收集所有账号的账户信息数据"""
-        all_account_data = []
-        
-        try:
-            # 按交易所分组账号
-            account_groups = self._group_accounts_by_exchange(accounts)
-            
-            # 并发收集每个交易所的数据
-            tasks = []
-            for exchange_id, account_list in account_groups.items():
-                task = self._collect_exchange_account_data(exchange_id, account_list)
-                tasks.append(task)
-            
-            # 等待所有任务完成并合并结果
-            results = await asyncio.gather(*tasks, return_exceptions=True)
-            
-            for result in results:
-                if isinstance(result, list):
-                    all_account_data.extend(result)
-            
-            logger.info(f"收集到 {len(all_account_data)} 条账户信息记录")
-            
-        except Exception as e:
-            logger.error(f"收集账户信息数据失败: {e}")
-        
-        return all_account_data
-    
-    def _group_accounts_by_exchange(self, accounts: Dict[str, Dict]) -> Dict[str, List[Dict]]:
-        """按交易所分组账号"""
-        groups = {}
-        for account_id, account_info in accounts.items():
-            exchange_id = account_info.get('exchange_id')
-            if exchange_id:
-                if exchange_id not in groups:
-                    groups[exchange_id] = []
-                groups[exchange_id].append(account_info)
-        return groups
-    
-    async def _collect_exchange_account_data(self, exchange_id: str, account_list: List[Dict]) -> List[Dict]:
-        """收集某个交易所的账户信息数据"""
-        account_data_list = []
-        
-        try:
-            for account_info in account_list:
-                k_id = int(account_info['k_id'])
-                st_id = account_info.get('st_id', 0)
-                
-                # 从Redis获取账户信息数据
-                account_data = await self._get_account_info_from_redis(k_id, st_id, exchange_id)
-                account_data_list.extend(account_data)
-            
-            logger.debug(f"交易所 {exchange_id}: 收集到 {len(account_data_list)} 条账户信息")
-            
-        except Exception as e:
-            logger.error(f"收集交易所 {exchange_id} 账户信息失败: {e}")
-        
-        return account_data_list
-    
-    async def _get_account_info_from_redis(self, k_id: int, st_id: int, exchange_id: str) -> List[Dict]:
-        """从Redis获取账户信息数据（批量优化版本）"""
-        try:
-            redis_key = f"{exchange_id}:balance:{k_id}"
-            redis_funds = self.redis_client.client.hgetall(redis_key)
-            
-            if not redis_funds:
-                return []
-            
-            # 按天统计数据
-            from config.settings import SYNC_CONFIG
-            recent_days = SYNC_CONFIG['recent_days']
-            
-            today = datetime.now()
-            date_stats = {}
-            
-            # 收集所有日期的数据
-            for fund_key, fund_json in redis_funds.items():
-                try:
-                    fund_data = json.loads(fund_json)
-                    date_str = fund_data.get('lz_time', '')
-                    lz_type = fund_data.get('lz_type', '')
-                    
-                    if not date_str or lz_type not in ['lz_balance', 'deposit', 'withdrawal']:
-                        continue
-                    
-                    # 只处理最近N天的数据
-                    date_obj = datetime.strptime(date_str, '%Y-%m-%d')
-                    if (today - date_obj).days > recent_days:
-                        continue
-                    
-                    if date_str not in date_stats:
-                        date_stats[date_str] = {
-                            'balance': 0.0,
-                            'deposit': 0.0,
-                            'withdrawal': 0.0,
-                            'has_balance': False
-                        }
-                    
-                    lz_amount = float(fund_data.get('lz_amount', 0))
-                    
-                    if lz_type == 'lz_balance':
-                        date_stats[date_str]['balance'] = lz_amount
-                        date_stats[date_str]['has_balance'] = True
-                    elif lz_type == 'deposit':
-                        date_stats[date_str]['deposit'] += lz_amount
-                    elif lz_type == 'withdrawal':
-                        date_stats[date_str]['withdrawal'] += lz_amount
-                        
-                except (json.JSONDecodeError, ValueError) as e:
-                    logger.debug(f"解析Redis数据失败: {fund_key}, error={e}")
-                    continue
-            
-            # 转换为账户信息数据
-            account_data_list = []
-            sorted_dates = sorted(date_stats.keys())
-            
-            # 获取前一天余额用于计算利润
-            prev_balance_map = self._get_previous_balances(redis_funds, sorted_dates)
-            
-            for date_str in sorted_dates:
-                stats = date_stats[date_str]
-                
-                # 如果没有余额数据但有充提数据，仍然处理
-                if not stats['has_balance'] and stats['deposit'] == 0 and stats['withdrawal'] == 0:
-                    continue
-                
-                balance = stats['balance']
-                deposit = stats['deposit']
-                withdrawal = stats['withdrawal']
-                
-                # 计算利润
-                prev_balance = prev_balance_map.get(date_str, 0.0)
-                profit = balance - deposit - withdrawal - prev_balance
-                
-                # 转换时间戳
-                date_obj = datetime.strptime(date_str, '%Y-%m-%d')
-                time_timestamp = int(date_obj.timestamp())
-                
-                account_data = {
-                    'st_id': st_id,
-                    'k_id': k_id,
-                    'balance': balance,
-                    'withdrawal': withdrawal,
-                    'deposit': deposit,
-                    'other': 0.0,  # 暂时为0
-                    'profit': profit,
-                    'time': time_timestamp
-                }
-                
-                account_data_list.append(account_data)
-            
-            return account_data_list
-            
-        except Exception as e:
-            logger.error(f"获取Redis账户信息失败: k_id={k_id}, error={e}")
-            return []
-    
-    def _get_previous_balances(self, redis_funds: Dict, sorted_dates: List[str]) -> Dict[str, float]:
-        """获取前一天的余额"""
-        prev_balance_map = {}
-        prev_date = None
-        
-        for date_str in sorted_dates:
-            # 查找前一天的余额
-            if prev_date:
-                for fund_key, fund_json in redis_funds.items():
-                    try:
-                        fund_data = json.loads(fund_json)
-                        if (fund_data.get('lz_time') == prev_date and 
-                            fund_data.get('lz_type') == 'lz_balance'):
-                            prev_balance_map[date_str] = float(fund_data.get('lz_amount', 0))
-                            break
-                    except:
-                        continue
-            else:
-                prev_balance_map[date_str] = 0.0
-            
-            prev_date = date_str
-        
-        return prev_balance_map
-    
+
+
     async def _sync_account_info_batch_to_db(self, account_data_list: List[Dict]) -> bool:
         """批量同步账户信息到数据库（最高效版本）"""
         session = self.db_manager.get_session()

sync/base_sync.py

@@ -24,11 +24,6 @@ class BaseSync(ABC):
             'avg_sync_time': 0
         }
     
-
-    @abstractmethod
-    async def sync(self):
-        """执行同步（兼容旧接口）"""
-        pass
     
     @abstractmethod
     async def sync_batch(self, accounts: Dict[str, Dict]):

sync/manager.py

@@ -5,7 +5,6 @@ import sys
 import time
 import json
 from typing import Dict
-import re
 import utils.helpers as helpers
 
 from utils.redis_client import RedisClient
@@ -24,8 +23,6 @@ class SyncManager:
         self.is_running = True
         self.redis_client = RedisClient()
         self.sync_interval = SYNC_CONFIG['interval']
-        self.computer_names = self._get_computer_names()
-        self.computer_name_pattern = re.compile(COMPUTER_NAME_PATTERN)
         
         # 初始化批量同步工具
         self.redis_helper = None
@@ -70,7 +67,7 @@ class SyncManager:
             try:
                 
                 # 获取所有账号（只获取一次）
-                accounts = self.get_accounts_from_redis()
+                accounts = self.redis_client.get_accounts_from_redis()
                 
                 if not accounts:
                     logger.warning("未获取到任何账号，等待下次同步")
@@ -111,239 +108,6 @@ class SyncManager:
                 logger.error("完整堆栈跟踪:\n{traceback}", traceback=error_details['traceback'])
                 await asyncio.sleep(30)
     
-    def get_accounts_from_redis(self) -> Dict[str, Dict]:
-        """从Redis获取所有计算机名的账号配置"""
-        try:
-            accounts_dict = {}
-            total_keys_processed = 0
-            
-            # 方法1：使用配置的计算机名列表
-            for computer_name in self.computer_names:
-                accounts = self._get_accounts_by_computer_name(computer_name)
-                total_keys_processed += 1
-                accounts_dict.update(accounts)
-            
-            # 方法2：如果配置的计算机名没有数据，尝试自动发现（备用方案）
-            if not accounts_dict:
-                logger.warning("配置的计算机名未找到数据，尝试自动发现...")
-                accounts_dict = self._discover_all_accounts()
-            
-            logger.info(f"从 {len(self.computer_names)} 个计算机名获取到 {len(accounts_dict)} 个账号")
-            
-            return accounts_dict
-            
-        except Exception as e:
-            logger.error(f"获取账户信息失败: {e}")
-            return {}
-
-    def _get_computer_names(self) -> List[str]:
-        """获取计算机名列表"""
-        if ',' in COMPUTER_NAMES:
-            names = [name.strip() for name in COMPUTER_NAMES.split(',')]
-            logger.info(f"使用配置的计算机名列表: {names}")
-            return names
-        return [COMPUTER_NAMES.strip()]
-
-    def _get_accounts_by_computer_name(self, computer_name: str) -> Dict[str, Dict]:
-        """获取指定计算机名的账号"""
-        accounts_dict = {}
-        
-        try:
-            # 构建key
-            redis_key = f"{computer_name}_strategy_api"
-            
-            # 从Redis获取数据
-            result = self.redis_client.client.hgetall(redis_key)
-            if not result:
-                logger.debug(f"未找到 {redis_key} 的策略API配置")
-                return {}
-            
-            logger.info(f"从 {redis_key} 获取到 {len(result)} 个交易所配置")
-            
-            for exchange_name, accounts_json in result.items():
-                try:
-                    accounts = json.loads(accounts_json)
-                    if not accounts:
-                        continue
-                    
-                    # 格式化交易所ID
-                    exchange_id = self.format_exchange_id(exchange_name)
-                    
-                    for account_id, account_info in accounts.items():
-                        parsed_account = self.parse_account(exchange_id, account_id, account_info)
-                        if parsed_account:
-                            # 添加计算机名标记
-                            parsed_account['computer_name'] = computer_name
-                            accounts_dict[account_id] = parsed_account
-                            
-                except json.JSONDecodeError as e:
-                    logger.error(f"解析交易所 {exchange_name} 的JSON数据失败: {e}")
-                    continue
-                except Exception as e:
-                    logger.error(f"处理交易所 {exchange_name} 数据异常: {e}")
-                    continue
-            
-            logger.info(f"从 {redis_key} 解析到 {len(accounts_dict)} 个账号")
-            
-        except Exception as e:
-            logger.error(f"获取计算机名 {computer_name} 的账号失败: {e}")
-        
-        return accounts_dict
-
-    def _discover_all_accounts(self) -> Dict[str, Dict]:
-        """自动发现所有匹配的账号key"""
-        accounts_dict = {}
-        discovered_keys = []
-        
-        try:
-            # 获取所有匹配模式的key
-            pattern = "*_strategy_api"
-            cursor = 0
-            
-            while True:
-                cursor, keys = self.redis_client.client.scan(cursor, match=pattern, count=100)
-                
-                for key in keys:
-                    key_str = key.decode('utf-8') if isinstance(key, bytes) else key
-                    discovered_keys.append(key_str)
-                
-                if cursor == 0:
-                    break
-            
-            logger.info(f"自动发现 {len(discovered_keys)} 个策略API key")
-            
-            # 处理每个发现的key
-            for key_str in discovered_keys:
-                # 提取计算机名
-                computer_name = key_str.replace('_strategy_api', '')
-                
-                # 验证计算机名格式
-                if self.computer_name_pattern.match(computer_name):
-                    accounts = self._get_accounts_by_computer_name(computer_name)
-                    accounts_dict.update(accounts)
-                else:
-                    logger.warning(f"跳过不符合格式的计算机名: {computer_name}")
-            
-            logger.info(f"自动发现共获取到 {len(accounts_dict)} 个账号")
-            
-        except Exception as e:
-            logger.error(f"自动发现账号失败: {e}")
-        
-        return accounts_dict
-    
-    def _discover_all_accounts(self) -> Dict[str, Dict]:
-        """自动发现所有匹配的账号key"""
-        accounts_dict = {}
-        discovered_keys = []
-        
-        try:
-            # 获取所有匹配模式的key
-            pattern = "*_strategy_api"
-            cursor = 0
-            
-            while True:
-                cursor, keys = self.redis_client.client.scan(cursor, match=pattern, count=100)
-                
-                for key in keys:
-                    key_str = key.decode('utf-8') if isinstance(key, bytes) else key
-                    discovered_keys.append(key_str)
-                
-                if cursor == 0:
-                    break
-            
-            logger.info(f"自动发现 {len(discovered_keys)} 个策略API key")
-            
-            # 处理每个发现的key
-            for key_str in discovered_keys:
-                # 提取计算机名
-                computer_name = key_str.replace('_strategy_api', '')
-                
-                # 验证计算机名格式
-                if self.computer_name_pattern.match(computer_name):
-                    accounts = self._get_accounts_by_computer_name(computer_name)
-                    accounts_dict.update(accounts)
-                else:
-                    logger.warning(f"跳过不符合格式的计算机名: {computer_name}")
-            
-            logger.info(f"自动发现共获取到 {len(accounts_dict)} 个账号")
-            
-        except Exception as e:
-            logger.error(f"自动发现账号失败: {e}")
-        
-        return accounts_dict
-    
-    def format_exchange_id(self, key: str) -> str:
-        """格式化交易所ID"""
-        key = key.lower().strip()
-        
-        # 交易所名称映射
-        exchange_mapping = {
-            'metatrader': 'mt5',
-            'binance_spot_test': 'binance',
-            'binance_spot': 'binance',
-            'binance': 'binance',
-            'gate_spot': 'gate',
-            'okex': 'okx',
-            'okx': 'okx',
-            'bybit': 'bybit',
-            'bybit_spot': 'bybit',
-            'bybit_test': 'bybit',
-            'huobi': 'huobi',
-            'huobi_spot': 'huobi',
-            'gate': 'gate',
-            'gateio': 'gate',
-            'kucoin': 'kucoin',
-            'kucoin_spot': 'kucoin',
-            'mexc': 'mexc',
-            'mexc_spot': 'mexc',
-            'bitget': 'bitget',
-            'bitget_spot': 'bitget'
-        }
-        
-        normalized_key = exchange_mapping.get(key, key)
-        
-        # 记录未映射的交易所
-        if normalized_key == key and key not in exchange_mapping.values():
-            logger.debug(f"未映射的交易所名称: {key}")
-        
-        return normalized_key
-    
-    def parse_account(self, exchange_id: str, account_id: str, account_info: str) -> Optional[Dict]:
-        """解析账号信息"""
-        try:
-            source_account_info = json.loads(account_info)
-            # print(source_account_info)
-            # 基础信息
-            account_data = {
-                'exchange_id': exchange_id,
-                'k_id': account_id,
-                'st_id': helpers.safe_int(source_account_info.get('st_id'), 0),
-                'add_time': helpers.safe_int(source_account_info.get('add_time'), 0),
-                'api_key': source_account_info.get('api_key', ''),
-            }
-            
-            return account_data
-            
-        except json.JSONDecodeError as e:
-            logger.error(f"解析账号 {account_id} JSON数据失败: {e}, 原始数据: {account_info[:100]}...")
-            return None
-        except Exception as e:
-            logger.error(f"处理账号 {account_id} 数据异常: {e}")
-            return None
-    
-    def _group_accounts_by_exchange(self, accounts: Dict[str, Dict]) -> Dict[str, List[Dict]]:
-        """按交易所分组账号"""
-        groups = {}
-        for account_id, account_info in accounts.items():
-            exchange_id = account_info.get('exchange_id')
-            if exchange_id:
-                if exchange_id not in groups:
-                    groups[exchange_id] = []
-                groups[exchange_id].append(account_info)
-        return groups
-    
-
-
 
 
     def _update_stats(self, sync_time: float):

sync/position_sync.py

@@ -1,12 +1,9 @@
 from .base_sync import BaseSync
 from loguru import logger
 from typing import List, Dict, Any, Set, Tuple
-import json
-import asyncio
-import utils.helpers as helpers
-from datetime import datetime
 from sqlalchemy import text, and_, select, delete
 from models.orm_models import StrategyPosition
+import utils.helpers as helpers
 import time
 
 class PositionSyncBatch(BaseSync):
@@ -18,13 +15,15 @@ class PositionSyncBatch(BaseSync):
     
     async def sync_batch(self, accounts: Dict[str, Dict]):
         """批量同步所有账号的持仓数据"""
+        return
         try:
             logger.info(f"开始批量同步持仓数据，共 {len(accounts)} 个账号")
             
             start_time = time.time()
             
             # 1. 收集所有账号的持仓数据
-            all_positions = await self._collect_all_positions(accounts)
+            all_positions = await self.redis_client._collect_all_positions(accounts)
+            
             
             if not all_positions:
                 logger.info("无持仓数据需要同步")
@@ -421,91 +420,6 @@ class PositionSyncBatch(BaseSync):
         finally:
             session.close()
 
-    async def _collect_all_positions(self, accounts: Dict[str, Dict]) -> List[Dict]:
-        """收集所有账号的持仓数据"""
-        all_positions = []
-        
-        try:
-            # 按交易所分组账号
-            account_groups = self._group_accounts_by_exchange(accounts)
-            
-            # 并发收集每个交易所的数据
-            tasks = []
-            for exchange_id, account_list in account_groups.items():
-                task = self._collect_exchange_positions(exchange_id, account_list)
-                tasks.append(task)
-            
-            # 等待所有任务完成并合并结果
-            results = await asyncio.gather(*tasks, return_exceptions=True)
-            
-            for result in results:
-                if isinstance(result, list):
-                    all_positions.extend(result)
-            
-        except Exception as e:
-            logger.error(f"收集持仓数据失败: {e}")
-        
-        return all_positions
-    
-    def _group_accounts_by_exchange(self, accounts: Dict[str, Dict]) -> Dict[str, List[Dict]]:
-        """按交易所分组账号"""
-        groups = {}
-        for account_id, account_info in accounts.items():
-            exchange_id = account_info.get('exchange_id')
-            if exchange_id:
-                if exchange_id not in groups:
-                    groups[exchange_id] = []
-                groups[exchange_id].append(account_info)
-        return groups
-    
-    async def _collect_exchange_positions(self, exchange_id: str, account_list: List[Dict]) -> List[Dict]:
-        """收集某个交易所的持仓数据"""
-        positions_list = []
-        
-        try:
-            tasks = []
-            for account_info in account_list:
-                k_id = int(account_info['k_id'])
-                st_id = account_info.get('st_id', 0)
-                task = self._get_positions_from_redis(k_id, st_id, exchange_id)
-                tasks.append(task)
-            
-            # 并发获取
-            results = await asyncio.gather(*tasks, return_exceptions=True)
-            
-            for result in results:
-                if isinstance(result, list):
-                    positions_list.extend(result)
-            
-        except Exception as e:
-            logger.error(f"收集交易所 {exchange_id} 持仓数据失败: {e}")
-        
-        return positions_list
-    
-    async def _get_positions_from_redis(self, k_id: int, st_id: int, exchange_id: str) -> List[Dict]:
-        """从Redis获取持仓数据"""
-        try:
-            redis_key = f"{exchange_id}:positions:{k_id}"
-            redis_data = self.redis_client.client.hget(redis_key, 'positions')
-            
-            if not redis_data:
-                return []
-            
-            positions = json.loads(redis_data)
-            
-            # 添加账号信息
-            for position in positions:
-                # print(position['symbol'])
-                position['k_id'] = k_id
-                position['st_id'] = st_id
-                position['exchange_id'] = exchange_id
-            
-            return positions
-            
-        except Exception as e:
-            logger.error(f"获取Redis持仓数据失败: k_id={k_id}, error={e}")
-            return []
-
     def _convert_position_data(self, data: Dict) -> Dict:
         """转换持仓数据格式"""
         try:
@@ -531,7 +445,3 @@ class PositionSyncBatch(BaseSync):
             logger.error(f"转换持仓数据异常: {data}, error={e}")
             return {}
     
-    async def sync(self):
-        """兼容旧接口"""
-        accounts = self.get_accounts_from_redis()
-        await self.sync_batch(accounts)