Coverage for lib/lottie/parsers/sif/xml/wrappers.py: 67%

1from .utils import * 

2from .core_nodes import XmlDescriptor, ObjectRegistry 

3 

4 

5class XmlParamSif(XmlDescriptor): 

6 def __init__(self, name, child_node, default_ctor=None): 

7 super().__init__(name) 

8 self.child_node = child_node 

9 self.default_ctor = default_ctor or child_node 

10 

11 def from_xml(self, obj, parent: minidom.Element, registry: ObjectRegistry): 

12 for cn in xml_child_elements(parent, "param"): 12 ↛ 17line 12 didn't jump to line 17, because the loop on line 12 didn't complete

13 if cn.getAttribute("name") == self.name: 

14 value = self.child_node.from_dom(xml_first_element_child(cn), registry) 

15 break 

16 else: 

17 value = self.default() 

18 

19 setattr(obj, self.att_name, value) 

20 

21 def to_xml(self, obj, parent: minidom.Element, dom: minidom.Document): 

22 param = parent.appendChild(dom.createElement("param")) 

23 param.setAttribute("name", self.name) 

24 param.appendChild(getattr(obj, self.att_name).to_dom(dom)) 

25 return param 

26 

27 def clean(self, value): 

28 if not isinstance(value, self.child_node): 28 ↛ 29line 28 didn't jump to line 29, because the condition on line 28 was never true

29 raise ValueError("%s isn't a valid value for %s" % (value, self.name)) 

30 return value 

31 

32 def default(self): 

33 return self.default_ctor() 

34 

35 

36class SifNodeList: 

37 def __init__(self, type): 

38 self._items = [] 

39 self._type = type 

40 

41 def __len__(self): 

42 return len(self._items) 

43 

44 def __iter__(self): 

45 return iter(self._items) 

46 

47 def __getitem__(self, name): 

48 return self._items[name] 

49 

50 def __getslice__(self, i, j): 

51 return self._items[i:j] 

52 

53 def __setitem__(self, key, value: "Layer"): 

54 self.validate(value) 

55 self._items[key] = value 

56 

57 def append(self, value: "Layer"): 

58 self.validate(value) 

59 self._items.append(value) 

60 

61 def __str__(self): 

62 return str(self._items) 

63 

64 def __repr__(self): 

65 return "<SifNodeList %s>" % self._items 

66 

67 def validate(self, value): 

68 if not isinstance(value, self._type): 68 ↛ 69line 68 didn't jump to line 69, because the condition on line 68 was never true

69 raise ValueError("Not a valid object: %s" % value) 

70 

71 

72class XmlSifElement(XmlDescriptor): 

73 def __init__(self, name, child_node, nested=True): 

74 super().__init__(name) 

75 self.child_node = child_node 

76 self.nested = nested 

77 

78 def default(self): 

79 return self.child_node() 

80 

81 def from_python(self, value): 

82 if not isinstance(value, self.child_node): 

83 raise ValueError("Invalid value for %s: %s" % (self.name, value)) 

84 return value 

85 

86 def from_xml(self, obj, parent: minidom.Element, registry: ObjectRegistry): 

87 cn = xml_first_element_child(parent, self.name, allow_none=True) 

88 if cn: 

89 if self.nested: 

90 element = xml_first_element_child(cn) 

91 else: 

92 element = cn 

93 value = self.child_node.from_dom(element, registry) 

94 else: 

95 value = self.default() 

96 

97 setattr(obj, self.att_name, value) 

98 

99 def to_xml(self, obj, parent: minidom.Element, dom: minidom.Document): 

100 value = getattr(obj, self.att_name) 

101 if self.nested: 

102 node = dom.createElement(self.name) 

103 parent.appendChild(node) 

104 else: 

105 node = parent 

106 node.appendChild(value.to_dom(dom)) 

107 

108 

109class XmlList(XmlDescriptor): 

110 def __init__(self, child_node, name=None, wrapper_tag=None, tags=None): 

111 super().__init__(wrapper_tag or child_node._tag) 

112 self.child_node = child_node 

113 self.att_name = self.att_name + "s" if name is None else name 

114 self.wrapper_tag = wrapper_tag 

115 if tags is None: 

116 self.tags = {self.name} 

117 else: 

118 self.tags = tags 

119 

120 def default(self): 

121 return SifNodeList(self.child_node) 

122 

123 def clean(self, value): 

124 return value 

125 

126 def from_xml(self, obj, parent: minidom.Element, registry: ObjectRegistry): 

127 values = self.default() 

128 for cn in xml_child_elements(parent): 

129 if cn.tagName in self.tags: 

130 value_node = cn 

131 if self.wrapper_tag: 

132 value_node = xml_first_element_child(cn) 

133 values.append(self.child_node.from_dom(value_node, registry)) 

134 

135 setattr(obj, self.att_name, values) 

136 

137 def to_xml(self, obj, parent: minidom.Element, dom: minidom.Document): 

138 for value in getattr(obj, self.att_name): 

139 value_node = value.to_dom(dom) 

140 if self.wrapper_tag: 

141 wrapper = dom.createElement(self.wrapper_tag) 

142 wrapper.appendChild(value_node) 

143 value_node = wrapper 

144 parent.appendChild(value_node) 

145 

146 

147class XmlWrapper(XmlDescriptor): 

148 def __init__(self, name, wrapped: XmlDescriptor): 

149 super().__init__(name) 

150 self.wrapped = wrapped 

151 

152 def to_xml(self, obj, parent: minidom.Element, dom: minidom.Document): 

153 wrapper = parent.appendChild(dom.createElement(self.name)) 

154 self.wrapped.to_xml(obj, wrapper, dom) 

155 

156 def from_xml(self, obj, parent: minidom.Element, registry: ObjectRegistry): 

157 wrapper = xml_first_element_child(parent, self.name, True) 

158 if wrapper: 

159 return self.wrapped.from_xml(obj, wrapper, registry) 

160 return self.default() 

161 

162 def from_python(self, value): 

163 return self.wrapped.from_python(value) 

164 

165 def initialize_object(self, dict, obj): 

166 return self.wrapped.initialize_object(dict, obj) 

167 

168 def clean(self, value): 

169 return self.wrapped.clean(value) 

170 

171 def default(self): 

172 return self.wrapped.default() 

173 

174 

175class XmlWrapperParam(XmlWrapper): 

176 def to_xml(self, obj, parent: minidom.Element, dom: minidom.Document): 

177 wrapper = parent.appendChild(dom.createElement("param")) 

178 wrapper.setAttribute("name", self.name) 

179 self.wrapped.to_xml(obj, wrapper, dom) 

180 

181 def from_xml(self, obj, parent: minidom.Element, registry: ObjectRegistry): 

182 for wrapper in xml_child_elements(parent, "param"): 182 ↛ 185line 182 didn't jump to line 185, because the loop on line 182 didn't complete

183 if wrapper.getAttribute("name") == self.name: 

184 return self.wrapped.from_xml(obj, wrapper, registry) 

185 return self.default() 

186 

187 

188class XmlBoneReference(XmlDescriptor): 

189 def __init__(self, name): 

190 super().__init__(name) 

191 

192 def to_xml(self, obj, parent: minidom.Element, dom: minidom.Document): 

193 value = getattr(obj, self.name, None) 

194 if not value: 

195 return 

196 

197 node = parent.appendChild(dom.createElement(self.name)) 

198 value_node = node.appendChild(dom.createElement("bone_valuenode")) 

199 value_node.setAttribute("type", value.type) 

200 value_node.setAttribute("guid", value.guid) 

201 

202 return node 

203 

204 def from_xml(self, obj, parent: minidom.Element, registry: ObjectRegistry): 

205 node = xml_first_element_child(parent, self.name, True) 

206 value = None 

207 if node: 

208 value_node = xml_first_element_child(node, "bone_valuenode", True) 

209 if value_node: 

210 value = registry.get_object(value_node.getAttribute("guid")) 

211 if value.type != value_node.getAttribute("type"): 

212 raise ValueError("Bone type %s is not %s" % (value.type, value_node.getAttribute("type"))) 

213 

214 setattr(obj, self.att_name, value) 

215 

216 def from_python(self, value): 

217 return value