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

1#!/usr/bin/env python

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

3

4"""

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

6"""

7

8 from typing import Any, Dict, List, Union

9

10

11 class 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