Coverage for aipyapp/aipy/event_serializer.py: 27%

1#!/usr/bin/env python 

2# -*- coding: utf-8 -*- 

3 

4""" 

5对象序列化器 - 统一处理事件中的对象序列化和反序列化 

6""" 

7 

8from typing import Any, Dict, List, Union 

9 

10 

11class EventSerializer: 

12 """对象序列化器 - 处理事件数据中的对象序列化和反序列化""" 

13 

14 @staticmethod 

15 def serialize(data: Any) -> Any: 

16 """序列化数据中的对象 

17  

18 Args: 

19 data: 待序列化的数据 

20  

21 Returns: 

22 序列化后的数据 

23 """ 

24 if isinstance(data, dict): 

25 result = {} 

26 for key, value in data.items(): 

27 result[key] = EventSerializer.serialize(value) 

28 return result 

29 elif isinstance(data, (list, tuple)): 

30 return [EventSerializer.serialize(item) for item in data] 

31 elif hasattr(data, 'to_dict'): 

32 # 对象有 to_dict 方法，使用它进行序列化 

33 return data.to_dict() 

34 else: 

35 # 基本类型直接返回 

36 return data 

37 

38 @staticmethod 

39 def deserialize(data: Any) -> Any: 

40 """反序列化数据中的对象 

41  

42 Args: 

43 data: 待反序列化的数据 

44  

45 Returns: 

46 反序列化后的数据 

47 """ 

48 if isinstance(data, dict): 

49 # 检查是否是序列化的对象 

50 if '__type__' in data: 

51 return EventSerializer._reconstruct_object(data) 

52 else: 

53 # 递归处理字典 

54 result = {} 

55 for key, value in data.items(): 

56 result[key] = EventSerializer.deserialize(value) 

57 return result 

58 elif isinstance(data, list): 

59 return [EventSerializer.deserialize(item) for item in data] 

60 else: 

61 # 基本类型直接返回 

62 return data 

63 

64 @staticmethod 

65 def _reconstruct_object(data: Dict[str, Any]) -> Any: 

66 """根据类型信息重构对象 

67  

68 Args: 

69 data: 包含类型信息的字典 

70  

71 Returns: 

72 重构的对象，如果类型未知则返回原始数据 

73 """ 

74 obj_type = data.get('__type__') 

75 

76 if obj_type == 'ChatMessage': 

77 from ..llm.base import ChatMessage 

78 return ChatMessage.from_dict(data) 

79 elif obj_type == 'CodeBlock': 

80 from .blocks import CodeBlock 

81 return CodeBlock.from_dict(data) 

82 else: 

83 # 未知类型，返回原始数据 

84 return data 

85 

86 @staticmethod 

87 def serialize_event_data(event_data: Dict[str, Any]) -> Dict[str, Any]: 

88 """序列化事件数据 

89  

90 Args: 

91 event_data: 事件数据字典 

92  

93 Returns: 

94 序列化后的事件数据 

95 """ 

96 if not isinstance(event_data, dict): 

97 return event_data 

98 

99 return EventSerializer.serialize(event_data.copy()) 

100 

101 @staticmethod 

102 def deserialize_event_data(event_data: Dict[str, Any]) -> Dict[str, Any]: 

103 """反序列化事件数据 

104  

105 Args: 

106 event_data: 序列化的事件数据字典 

107  

108 Returns: 

109 反序列化后的事件数据 

110 """ 

111 if not isinstance(event_data, dict): 

112 return event_data 

113 

114 return EventSerializer.deserialize(event_data.copy()) 

115 

116 @staticmethod 

117 def serialize_events(events: List[Dict[str, Any]]) -> List[Dict[str, Any]]: 

118 """序列化事件列表 

119  

120 Args: 

121 events: 事件列表 

122  

123 Returns: 

124 序列化后的事件列表 

125 """ 

126 serialized_events = [] 

127 for event in events: 

128 serialized_event = event.copy() 

129 if 'data' in serialized_event: 

130 serialized_event['data'] = EventSerializer.serialize_event_data(serialized_event['data']) 

131 serialized_events.append(serialized_event) 

132 return serialized_events 

133 

134 @staticmethod 

135 def deserialize_events(events: List[Dict[str, Any]]) -> List[Dict[str, Any]]: 

136 """反序列化事件列表（用于重放） 

137  

138 Args: 

139 events: 序列化的事件列表 

140  

141 Returns: 

142 反序列化后的事件列表 

143 """ 

144 deserialized_events = [] 

145 for event in events: 

146 deserialized_event = event.copy() 

147 if 'data' in deserialized_event: 

148 deserialized_event['data'] = EventSerializer.deserialize_event_data(deserialized_event['data']) 

149 deserialized_events.append(deserialized_event) 

150 return deserialized_events 

151 

152 @staticmethod 

153 def register_serializable_type(type_name: str, from_dict_func: callable): 

154 """注册新的可序列化类型 

155  

156 Args: 

157 type_name: 类型名称（与 __type__ 字段对应） 

158 from_dict_func: 从字典重构对象的函数 

159 """ 

160 # 这里可以扩展为动态注册机制 

161 # 目前硬编码在 _reconstruct_object 中 

162 pass