Coverage for auttcomp/testing/test_shape_eval.py: 98%

136 statements  

« prev     ^ index     » next       coverage.py v7.6.12, created at 2025-02-24 12:00 -0600

1from collections import namedtuple 

2from ..shape_eval import eval_shape, ShapeNode, node_graph_to_obj, DictShape, ListShape, TupleShape 

3from ..quicklog import tracelog, log 

4from types import SimpleNamespace 

5from ..extensions import Api as f 

6from .base_test import get_civitai_sample 

7import json 

8 

9@tracelog("test_shape_node") 

10def test_shape_node(): 

11 main = ShapeNode({}) 

12 foo = main.add_child(ShapeNode(container_type="foo")) 

13 foo.add_child(ShapeNode(value="str")) 

14 r = node_graph_to_obj(main) 

15 assert r == {"foo": "str"} 

16 

17@tracelog("test_shape_node2") 

18def test_shape_node2(): 

19 main = ShapeNode({}) 

20 foo = main.add_child(ShapeNode(container_type="foo")) 

21 foo.add_child(ShapeNode(value="str")) 

22 foo.add_child(ShapeNode(value="int")) 

23 r = node_graph_to_obj(main) 

24 assert r == {"foo": "str|int"} 

25 

26@tracelog("test_eval_shape_prim") 

27def test_eval_shape_prim(): 

28 d = 1 

29 s = eval_shape(d) 

30 assert s == 'int' 

31 

32@tracelog("test_eval_shape_list_empty") 

33def test_eval_shape_list_empty(): 

34 d = [] 

35 s = eval_shape(d) 

36 assert s == [] 

37 

38@tracelog("test_eval_shape_list") 

39def test_eval_shape_list(): 

40 d = [1, 2, 2, 2] 

41 s = eval_shape(d) 

42 assert s == ['int'] 

43 

44@tracelog("test_eval_shape_list1") 

45def test_eval_shape_list1(): 

46 d = [1, 2, 2.0, 2] 

47 s = eval_shape(d) 

48 assert s == ['int', 'float'] 

49 

50@tracelog("test_eval_shape_list2") 

51def test_eval_shape_list2(): 

52 d = [[1, 2, 2, 2], [1, 2, 2, 2]] 

53 s = eval_shape(d) 

54 assert s == [['int']] 

55 

56@tracelog("test_eval_shape_list3") 

57def test_eval_shape_list3(): 

58 d = [[1, 2, 2.0, 2], [1, 2, 2.0, 2]] 

59 s = eval_shape(d) 

60 assert s == [['int', 'float']] 

61 

62@tracelog("test_eval_shape_list4") 

63def test_eval_shape_list4(): 

64 d = [ 1, [1, 2, 2.0, 2], [1, 2, 2.0, 2]] 

65 s = eval_shape(d) 

66 assert s == ['int', ['int', 'float']] 

67 

68@tracelog("test_eval_shape_dict_empty") 

69def test_eval_shape_dict_empty(): 

70 d = {} 

71 s = eval_shape(d) 

72 assert s == {} 

73 

74@tracelog("test_eval_shape_dict1") 

75def test_eval_shape_dict1(): 

76 d = {"val": 1} 

77 s = eval_shape(d) 

78 assert s == {"val": "int"} 

79 

80@tracelog("test_eval_shape_dict2") 

81def test_eval_shape_dict2(): 

82 d = {"val": 1, "nested": {"n1": 2}} 

83 s = eval_shape(d) 

84 assert s == {"val": "int", "nested": {"n1": "int"}} 

85 

86@tracelog("test_eval_shape_dict2") 

87def test_eval_shape_dict2(): 

88 d = [ 

89 {"val": 1, "nested": {"n1": 2}}, 

90 {"val": 1, "nested": {"n1": 2, "extra": "hello"}} 

91 ] 

92 

93 s = eval_shape(d) 

94 assert s == [{"val": "int", "nested": {"n1": "int", "extra": "str"}}] 

95 

96@tracelog("test_eval_shape_dict3") 

97def test_eval_shape_dict3(): 

98 json_str = """ 

99 { 

100 "l1": { 

101 "l2p1": [1], 

102 "l2p2": ["x"] 

103 } 

104 } 

105 """ 

106 

107 json_obj = json.loads(json_str, object_hook=lambda d: SimpleNamespace(**d)) 

108 s = eval_shape(json_obj) 

109 assert s == {"l1": {"l2p1": ['int'], "l2p2": ["str"]}} 

110 

111@tracelog("test_eval_shape_dict4") 

112def test_eval_shape_dict4(): 

113 obj = { 

114 "l2p1": [("foo", (1,))], 

115 "l2p2": ("x", 123) 

116 } 

117 

118 s = eval_shape(obj) 

119 assert s == {"l2p1": [("str", ('int',))], "l2p2": ("str", 'int')} 

120 

121@tracelog("test_shapeEval_getAttr_returns_shape") 

122def test_shape_eval_get_attr_returns_shape(): 

123 obj = { 

124 "l2p1": [("foo", (1,))], 

125 "l2p2": ("x", 123) 

126 } 

127 

128 s = eval_shape(obj) 

129 assert isinstance(s, DictShape) 

130 assert isinstance(s.l2p1, ListShape) 

131 

132 s1 = s.l2p1[0] 

133 assert isinstance(s1, TupleShape), f"the shape is {type(s1)}" 

134 

135@tracelog("test_tuple_with_list") 

136def test_tuple_with_list(): 

137 tup = namedtuple("mytup", ["a", "b", "c"]) 

138 t1 = tup(1, 2, [1]) 

139 sh = eval_shape(t1) 

140 assert sh == ('int', 'int', ['int']) 

141 

142@tracelog("test_tuple_with_dict") 

143def test_tuple_with_dict(): 

144 tup = namedtuple("mytup", ["a", "b", "c"]) 

145 t1 = tup(1, 2, {"foo": 1}) 

146 sh = eval_shape(t1) 

147 assert sh == ('int', 'int', {"foo": 'int'}) 

148 

149@tracelog("test_tuple_with_dupes") 

150def test_tuple_with_dupes(): 

151 tup = namedtuple("mytup", ["a", "b", "c"]) 

152 t1 = tup(1, 2, 3) 

153 sh = eval_shape(t1) 

154 assert sh == ('int', 'int', 'int') 

155 

156@tracelog("test_tuple_with_dupes_arr") 

157def test_tuple_with_dupes_arr(): 

158 tup = namedtuple("mytup", ["a", "b", "c"]) 

159 t1 = [tup(1, 2, 3), tup(1, 2, 3)] 

160 sh = eval_shape(t1) 

161 assert sh == [('int', 'int', 'int')] 

162 

163@tracelog("test_dict_sometimes_null") 

164def test_dict_sometimes_null(): 

165 d1 = {"val": 1, "nested": {"n1": 2}} 

166 d2 = {"val": 1, "nested": None} 

167 s = eval_shape([d1, d2]) 

168 assert s == [{"val": "int", "nested?": {"n1": "int"}}] 

169 

170@tracelog("test_dict_only_null_props") 

171def test_dict_only_null_props(): 

172 d1 = {"val": 1, "nested": None} 

173 d2 = {"val": 1, "nested": None} 

174 s = eval_shape([d1, d2]) 

175 assert s == [{"val": "int", "nested?": "None"}] 

176 

177@tracelog("test_complex_obj_civitai") 

178def test_complex_obj_civitai(): 

179 obj = get_civitai_sample() 

180 f.id(obj.result.data.json.collection) > f.shape 

181 #does not throw