tcmmichaelb139 commited on
Commit
80b5ee0
·
1 Parent(s): 4187a7b

hf test updated (docker works now)

Browse files
Files changed (1) hide show
  1. tests/test_hf_api.py +34 -29
tests/test_hf_api.py CHANGED
@@ -12,10 +12,15 @@ def get_final_answer(text: str) -> int | None:
12
  BASE_URL = "https://tcmmichaelb139-evolutiontransformer.hf.space"
13
 
14
 
15
- def await_task_completion(task_id, timeout=60):
 
 
 
 
 
16
  start_time = time.time()
17
  while time.time() - start_time < timeout:
18
- status_response = requests.get(f"{BASE_URL}/tasks/{task_id}")
19
 
20
  print(status_response.json())
21
 
@@ -36,11 +41,11 @@ def await_task_completion(task_id, timeout=60):
36
  return None
37
 
38
 
39
- def test_generate_endpoint_svamp():
40
  """
41
  Tests inference on svamp
42
  """
43
- response = requests.post(
44
  f"{BASE_URL}/generate",
45
  json={
46
  "model_name": "svamp",
@@ -56,7 +61,7 @@ def test_generate_endpoint_svamp():
56
  assert "task_id" in data
57
  task_id = data["task_id"]
58
 
59
- final_result = await_task_completion(task_id)
60
 
61
  assert "response" in final_result
62
  output_text = final_result["response"]
@@ -65,12 +70,12 @@ def test_generate_endpoint_svamp():
65
  assert answer == 14
66
 
67
 
68
- def test_merge_then_inference_svamp_1():
69
  """
70
  Tests merging then inference for svamp dataset
71
  """
72
 
73
- merge_response = requests.post(
74
  f"{BASE_URL}/merge",
75
  json={
76
  "model1_name": "svamp",
@@ -87,12 +92,12 @@ def test_merge_then_inference_svamp_1():
87
  assert "task_id" in merge_data
88
  merge_task_id = merge_data["task_id"]
89
 
90
- merge_status_data = await_task_completion(merge_task_id)
91
  model_name = merge_status_data["response"]
92
 
93
  time.sleep(5)
94
 
95
- generate_response = requests.post(
96
  f"{BASE_URL}/generate",
97
  json={
98
  "model_name": model_name,
@@ -107,7 +112,7 @@ def test_merge_then_inference_svamp_1():
107
  assert "task_id" in generate_data
108
  generate_task_id = generate_data["task_id"]
109
 
110
- final_result = await_task_completion(generate_task_id)
111
 
112
  assert "response" in final_result
113
  output_text = final_result["response"]
@@ -116,12 +121,12 @@ def test_merge_then_inference_svamp_1():
116
  assert answer == 14
117
 
118
 
119
- def test_merge_then_inference_svamp_2():
120
  """
121
  Tests merging then inference for svamp dataset
122
  """
123
 
124
- merge_repsonse = requests.post(
125
  f"{BASE_URL}/merge",
126
  json={
127
  "model1_name": "svamp",
@@ -138,11 +143,11 @@ def test_merge_then_inference_svamp_2():
138
  assert "task_id" in merge_data
139
  merge_task_id = merge_data["task_id"]
140
 
141
- merge_status_data = await_task_completion(merge_task_id)
142
 
143
  model_name = merge_status_data["response"]
144
 
145
- merge_response2 = requests.post(
146
  f"{BASE_URL}/merge",
147
  json={
148
  "model1_name": model_name,
@@ -158,12 +163,12 @@ def test_merge_then_inference_svamp_2():
158
  merge_data2 = merge_response2.json()
159
  assert "task_id" in merge_data2
160
  merge_task_id2 = merge_data2["task_id"]
161
- merge_status_data2 = await_task_completion(merge_task_id2)
162
  model_name2 = merge_status_data2["response"]
163
 
164
  time.sleep(5)
165
 
166
- generate_response = requests.post(
167
  f"{BASE_URL}/generate",
168
  json={
169
  "model_name": model_name2,
@@ -178,7 +183,7 @@ def test_merge_then_inference_svamp_2():
178
  assert "task_id" in generate_data
179
  generate_task_id = generate_data["task_id"]
180
 
181
- final_result = await_task_completion(generate_task_id)
182
 
183
  assert "response" in final_result
184
  output_text = final_result["response"]
@@ -187,12 +192,12 @@ def test_merge_then_inference_svamp_2():
187
  assert answer == 14
188
 
189
 
190
- def test_merge_two_children_then_merge():
191
  """
192
  Tests creating two children and merging them
193
  """
194
 
195
- merge_response1 = requests.post(
196
  f"{BASE_URL}/merge",
197
  json={
198
  "model1_name": "svamp",
@@ -209,10 +214,10 @@ def test_merge_two_children_then_merge():
209
  merge_data1 = merge_response1.json()
210
  assert "task_id" in merge_data1
211
  merge_task_id1 = merge_data1["task_id"]
212
- merge_status_data1 = await_task_completion(merge_task_id1)
213
  child1_name = merge_status_data1["response"]
214
 
215
- merge_response2 = requests.post(
216
  f"{BASE_URL}/merge",
217
  json={
218
  "model1_name": "svamp",
@@ -229,10 +234,10 @@ def test_merge_two_children_then_merge():
229
  merge_data2 = merge_response2.json()
230
  assert "task_id" in merge_data2
231
  merge_task_id2 = merge_data2["task_id"]
232
- merge_status_data2 = await_task_completion(merge_task_id2)
233
  child2_name = merge_status_data2["response"]
234
 
235
- merge_response3 = requests.post(
236
  f"{BASE_URL}/merge",
237
  json={
238
  "model1_name": child1_name,
@@ -248,12 +253,12 @@ def test_merge_two_children_then_merge():
248
  merge_data3 = merge_response3.json()
249
  assert "task_id" in merge_data3
250
  merge_task_id3 = merge_data3["task_id"]
251
- merge_status_data3 = await_task_completion(merge_task_id3)
252
  final_model_name = merge_status_data3["response"]
253
 
254
  time.sleep(5)
255
 
256
- generate_response = requests.post(
257
  f"{BASE_URL}/generate",
258
  json={
259
  "model_name": final_model_name,
@@ -268,7 +273,7 @@ def test_merge_two_children_then_merge():
268
  assert "task_id" in generate_data
269
  generate_task_id = generate_data["task_id"]
270
 
271
- final_result = await_task_completion(generate_task_id)
272
 
273
  assert "response" in final_result
274
  output_text = final_result["response"]
@@ -277,12 +282,12 @@ def test_merge_two_children_then_merge():
277
  assert answer == 14
278
 
279
 
280
- def test_merge_fail():
281
  """
282
  Tests merging with too many layers
283
  """
284
 
285
- merge_repsonse = requests.post(
286
  f"{BASE_URL}/merge",
287
  json={
288
  "model1_name": "svamp",
@@ -299,7 +304,7 @@ def test_merge_fail():
299
  assert "task_id" in merge_data
300
  merge_task_id = merge_data["task_id"]
301
 
302
- merge_status_data = await_task_completion(merge_task_id)
303
  assert "response" not in merge_status_data
304
  assert "error" in merge_status_data
305
  assert "Layer recipe too long" in merge_status_data["error"]
 
12
  BASE_URL = "https://tcmmichaelb139-evolutiontransformer.hf.space"
13
 
14
 
15
+ @pytest.fixture
16
+ def session():
17
+ return requests.Session()
18
+
19
+
20
+ def await_task_completion(session, task_id, timeout=60):
21
  start_time = time.time()
22
  while time.time() - start_time < timeout:
23
+ status_response = session.get(f"{BASE_URL}/tasks/{task_id}")
24
 
25
  print(status_response.json())
26
 
 
41
  return None
42
 
43
 
44
+ def test_generate_endpoint_svamp(session):
45
  """
46
  Tests inference on svamp
47
  """
48
+ response = session.post(
49
  f"{BASE_URL}/generate",
50
  json={
51
  "model_name": "svamp",
 
61
  assert "task_id" in data
62
  task_id = data["task_id"]
63
 
64
+ final_result = await_task_completion(session, task_id)
65
 
66
  assert "response" in final_result
67
  output_text = final_result["response"]
 
70
  assert answer == 14
71
 
72
 
73
+ def test_merge_then_inference_svamp_1(session):
74
  """
75
  Tests merging then inference for svamp dataset
76
  """
77
 
78
+ merge_response = session.post(
79
  f"{BASE_URL}/merge",
80
  json={
81
  "model1_name": "svamp",
 
92
  assert "task_id" in merge_data
93
  merge_task_id = merge_data["task_id"]
94
 
95
+ merge_status_data = await_task_completion(session, merge_task_id)
96
  model_name = merge_status_data["response"]
97
 
98
  time.sleep(5)
99
 
100
+ generate_response = session.post(
101
  f"{BASE_URL}/generate",
102
  json={
103
  "model_name": model_name,
 
112
  assert "task_id" in generate_data
113
  generate_task_id = generate_data["task_id"]
114
 
115
+ final_result = await_task_completion(session, generate_task_id)
116
 
117
  assert "response" in final_result
118
  output_text = final_result["response"]
 
121
  assert answer == 14
122
 
123
 
124
+ def test_merge_then_inference_svamp_2(session):
125
  """
126
  Tests merging then inference for svamp dataset
127
  """
128
 
129
+ merge_repsonse = session.post(
130
  f"{BASE_URL}/merge",
131
  json={
132
  "model1_name": "svamp",
 
143
  assert "task_id" in merge_data
144
  merge_task_id = merge_data["task_id"]
145
 
146
+ merge_status_data = await_task_completion(session, merge_task_id)
147
 
148
  model_name = merge_status_data["response"]
149
 
150
+ merge_response2 = session.post(
151
  f"{BASE_URL}/merge",
152
  json={
153
  "model1_name": model_name,
 
163
  merge_data2 = merge_response2.json()
164
  assert "task_id" in merge_data2
165
  merge_task_id2 = merge_data2["task_id"]
166
+ merge_status_data2 = await_task_completion(session, merge_task_id2)
167
  model_name2 = merge_status_data2["response"]
168
 
169
  time.sleep(5)
170
 
171
+ generate_response = session.post(
172
  f"{BASE_URL}/generate",
173
  json={
174
  "model_name": model_name2,
 
183
  assert "task_id" in generate_data
184
  generate_task_id = generate_data["task_id"]
185
 
186
+ final_result = await_task_completion(session, generate_task_id)
187
 
188
  assert "response" in final_result
189
  output_text = final_result["response"]
 
192
  assert answer == 14
193
 
194
 
195
+ def test_merge_two_children_then_merge(session):
196
  """
197
  Tests creating two children and merging them
198
  """
199
 
200
+ merge_response1 = session.post(
201
  f"{BASE_URL}/merge",
202
  json={
203
  "model1_name": "svamp",
 
214
  merge_data1 = merge_response1.json()
215
  assert "task_id" in merge_data1
216
  merge_task_id1 = merge_data1["task_id"]
217
+ merge_status_data1 = await_task_completion(session, merge_task_id1)
218
  child1_name = merge_status_data1["response"]
219
 
220
+ merge_response2 = session.post(
221
  f"{BASE_URL}/merge",
222
  json={
223
  "model1_name": "svamp",
 
234
  merge_data2 = merge_response2.json()
235
  assert "task_id" in merge_data2
236
  merge_task_id2 = merge_data2["task_id"]
237
+ merge_status_data2 = await_task_completion(session, merge_task_id2)
238
  child2_name = merge_status_data2["response"]
239
 
240
+ merge_response3 = session.post(
241
  f"{BASE_URL}/merge",
242
  json={
243
  "model1_name": child1_name,
 
253
  merge_data3 = merge_response3.json()
254
  assert "task_id" in merge_data3
255
  merge_task_id3 = merge_data3["task_id"]
256
+ merge_status_data3 = await_task_completion(session, merge_task_id3)
257
  final_model_name = merge_status_data3["response"]
258
 
259
  time.sleep(5)
260
 
261
+ generate_response = session.post(
262
  f"{BASE_URL}/generate",
263
  json={
264
  "model_name": final_model_name,
 
273
  assert "task_id" in generate_data
274
  generate_task_id = generate_data["task_id"]
275
 
276
+ final_result = await_task_completion(session, generate_task_id)
277
 
278
  assert "response" in final_result
279
  output_text = final_result["response"]
 
282
  assert answer == 14
283
 
284
 
285
+ def test_merge_fail(session):
286
  """
287
  Tests merging with too many layers
288
  """
289
 
290
+ merge_repsonse = session.post(
291
  f"{BASE_URL}/merge",
292
  json={
293
  "model1_name": "svamp",
 
304
  assert "task_id" in merge_data
305
  merge_task_id = merge_data["task_id"]
306
 
307
+ merge_status_data = await_task_completion(session, merge_task_id)
308
  assert "response" not in merge_status_data
309
  assert "error" in merge_status_data
310
  assert "Layer recipe too long" in merge_status_data["error"]