mirror/gradio
2
0
Fork 0
mirror of https://github.com/gradio-app/gradio.git synced 2024-12-21 02:19:59 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #342 from gradio-app/abidlabs/windows-tests

Browse Source 
fixed tests to they pass on woindows Link T-6
This commit is contained in:
Abubakar Abid 2021-11-08 14:43:59 -06:00 committed by GitHub
commit 9b2280c33d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 160 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
gradio/component.py
View File

@ -61,6 +61,7 @@ class Component():
if "." in old_file_name: if "." in old_file_name:
uploaded_format = old_file_name.split(".")[-1].lower() uploaded_format = old_file_name.split(".")[-1].lower()
new_file_name += "." + uploaded_format new_file_name += "." + uploaded_format
file.close()
shutil.move(old_file_name, os.path.join(dir, label, new_file_name)) shutil.move(old_file_name, os.path.join(dir, label, new_file_name))
return label + "/" + new_file_name return label + "/" + new_file_name

179
test/test_inputs.py
View File

@ -29,10 +29,11 @@ class TestTextbox(unittest.TestCase):
self.assertEqual(text_input.preprocess("Hello World!"), "Hello World!") self.assertEqual(text_input.preprocess("Hello World!"), "Hello World!")
self.assertEqual(text_input.preprocess_example("Hello World!"), "Hello World!") self.assertEqual(text_input.preprocess_example("Hello World!"), "Hello World!")
self.assertEqual(text_input.serialize("Hello World!", True), "Hello World!") self.assertEqual(text_input.serialize("Hello World!", True), "Hello World!")
to_save = text_input.save_flagged("flagged", "text_input", "Hello World!", None) with tempfile.TemporaryDirectory() as tmpdirname:
self.assertEqual(to_save, "Hello World!") to_save = text_input.save_flagged(tmpdirname, "text_input", "Hello World!", None)
restored = text_input.restore_flagged(to_save) self.assertEqual(to_save, "Hello World!")
self.assertEqual(restored, "Hello World!") restored = text_input.restore_flagged(to_save)
self.assertEqual(restored, "Hello World!")
with self.assertWarns(DeprecationWarning): with self.assertWarns(DeprecationWarning):
numeric_text_input = gr.inputs.Textbox(type="number") numeric_text_input = gr.inputs.Textbox(type="number")
@ -72,10 +73,11 @@ class TestNumber(unittest.TestCase):
self.assertEqual(numeric_input.preprocess(3), 3.0) self.assertEqual(numeric_input.preprocess(3), 3.0)
self.assertEqual(numeric_input.preprocess_example(3), 3) self.assertEqual(numeric_input.preprocess_example(3), 3)
self.assertEqual(numeric_input.serialize(3, True), 3) self.assertEqual(numeric_input.serialize(3, True), 3)
to_save = numeric_input.save_flagged("flagged", "numeric_input", 3, None) with tempfile.TemporaryDirectory() as tmpdirname:
self.assertEqual(to_save, 3) to_save = numeric_input.save_flagged(tmpdirname, "numeric_input", 3, None)
restored = numeric_input.restore_flagged(to_save) self.assertEqual(to_save, 3)
self.assertEqual(restored, 3) restored = numeric_input.restore_flagged(to_save)
self.assertEqual(restored, 3)
self.assertIsInstance(numeric_input.generate_sample(), float) self.assertIsInstance(numeric_input.generate_sample(), float)
numeric_input.set_interpret_parameters(steps=3, delta=1, delta_type="absolute") numeric_input.set_interpret_parameters(steps=3, delta=1, delta_type="absolute")
self.assertEqual(numeric_input.get_interpretation_neighbors(1), ([-2.0, -1.0, 0.0, 2.0, 3.0, 4.0], {})) self.assertEqual(numeric_input.get_interpretation_neighbors(1), ([-2.0, -1.0, 0.0, 2.0, 3.0, 4.0], {}))
@ -100,10 +102,12 @@ class TestSlider(unittest.TestCase):
self.assertEqual(slider_input.preprocess(3.0), 3.0) self.assertEqual(slider_input.preprocess(3.0), 3.0)
self.assertEqual(slider_input.preprocess_example(3), 3) self.assertEqual(slider_input.preprocess_example(3), 3)
self.assertEqual(slider_input.serialize(3, True), 3) self.assertEqual(slider_input.serialize(3, True), 3)
to_save = slider_input.save_flagged("flagged", "slider_input", 3, None) with tempfile.TemporaryDirectory() as tmpdirname:
self.assertEqual(to_save, 3) to_save = slider_input.save_flagged(tmpdirname, "slider_input", 3, None)
restored = slider_input.restore_flagged(to_save) self.assertEqual(to_save, 3)
self.assertEqual(restored, 3) restored = slider_input.restore_flagged(to_save)
self.assertEqual(restored, 3)
self.assertIsInstance(slider_input.generate_sample(), int) self.assertIsInstance(slider_input.generate_sample(), int)
slider_input = gr.inputs.Slider(minimum=10, maximum=20, step=1, default=15, label="Slide Your Input") slider_input = gr.inputs.Slider(minimum=10, maximum=20, step=1, default=15, label="Slide Your Input")
self.assertEqual(slider_input.get_template_context(), { self.assertEqual(slider_input.get_template_context(), {
@ -133,10 +137,11 @@ class TestCheckbox(unittest.TestCase):
self.assertEqual(bool_input.preprocess(True), True) self.assertEqual(bool_input.preprocess(True), True)
self.assertEqual(bool_input.preprocess_example(True), True) self.assertEqual(bool_input.preprocess_example(True), True)
self.assertEqual(bool_input.serialize(True, True), True) self.assertEqual(bool_input.serialize(True, True), True)
to_save = bool_input.save_flagged("flagged", "bool_input", True, None) with tempfile.TemporaryDirectory() as tmpdirname:
self.assertEqual(to_save, True) to_save = bool_input.save_flagged(tmpdirname, "bool_input", True, None)
restored = bool_input.restore_flagged(to_save) self.assertEqual(to_save, True)
self.assertEqual(restored, True) restored = bool_input.restore_flagged(to_save)
self.assertEqual(restored, True)
self.assertIsInstance(bool_input.generate_sample(), bool) self.assertIsInstance(bool_input.generate_sample(), bool)
bool_input = gr.inputs.Checkbox(default=True, label="Check Your Input") bool_input = gr.inputs.Checkbox(default=True, label="Check Your Input")
self.assertEqual(bool_input.get_template_context(), { self.assertEqual(bool_input.get_template_context(), {
@ -163,10 +168,11 @@ class TestCheckboxGroup(unittest.TestCase):
self.assertEqual(checkboxes_input.preprocess(["a", "c"]), ["a", "c"]) self.assertEqual(checkboxes_input.preprocess(["a", "c"]), ["a", "c"])
self.assertEqual(checkboxes_input.preprocess_example(["a", "c"]), ["a", "c"]) self.assertEqual(checkboxes_input.preprocess_example(["a", "c"]), ["a", "c"])
self.assertEqual(checkboxes_input.serialize(["a", "c"], True), ["a", "c"]) self.assertEqual(checkboxes_input.serialize(["a", "c"], True), ["a", "c"])
to_save = checkboxes_input.save_flagged("flagged", "checkboxes_input", ["a", "c"], None) with tempfile.TemporaryDirectory() as tmpdirname:
self.assertEqual(to_save, '["a", "c"]') to_save = checkboxes_input.save_flagged(tmpdirname, "checkboxes_input", ["a", "c"], None)
restored = checkboxes_input.restore_flagged(to_save) self.assertEqual(to_save, '["a", "c"]')
self.assertEqual(restored, ["a", "c"]) restored = checkboxes_input.restore_flagged(to_save)
self.assertEqual(restored, ["a", "c"])
self.assertIsInstance(checkboxes_input.generate_sample(), list) self.assertIsInstance(checkboxes_input.generate_sample(), list)
checkboxes_input = gr.inputs.CheckboxGroup(choices=["a", "b", "c"], default=["a", "c"], checkboxes_input = gr.inputs.CheckboxGroup(choices=["a", "b", "c"], default=["a", "c"],
label="Check Your Inputs") label="Check Your Inputs")
@ -199,10 +205,11 @@ class TestRadio(unittest.TestCase):
self.assertEqual(radio_input.preprocess("c"), "c") self.assertEqual(radio_input.preprocess("c"), "c")
self.assertEqual(radio_input.preprocess_example("a"), "a") self.assertEqual(radio_input.preprocess_example("a"), "a")
self.assertEqual(radio_input.serialize("a", True), "a") self.assertEqual(radio_input.serialize("a", True), "a")
to_save = radio_input.save_flagged("flagged", "radio_input", "a", None) with tempfile.TemporaryDirectory() as tmpdirname:
self.assertEqual(to_save, 'a') to_save = radio_input.save_flagged(tmpdirname, "radio_input", "a", None)
restored = radio_input.restore_flagged(to_save) self.assertEqual(to_save, 'a')
self.assertEqual(restored, "a") restored = radio_input.restore_flagged(to_save)
self.assertEqual(restored, "a")
self.assertIsInstance(radio_input.generate_sample(), str) self.assertIsInstance(radio_input.generate_sample(), str)
radio_input = gr.inputs.Radio(choices=["a", "b", "c"], default="a", radio_input = gr.inputs.Radio(choices=["a", "b", "c"], default="a",
label="Pick Your One Input") label="Pick Your One Input")
@ -234,10 +241,11 @@ class TestDropdown(unittest.TestCase):
self.assertEqual(dropdown_input.preprocess("c"), "c") self.assertEqual(dropdown_input.preprocess("c"), "c")
self.assertEqual(dropdown_input.preprocess_example("a"), "a") self.assertEqual(dropdown_input.preprocess_example("a"), "a")
self.assertEqual(dropdown_input.serialize("a", True), "a") self.assertEqual(dropdown_input.serialize("a", True), "a")
to_save = dropdown_input.save_flagged("flagged", "dropdown_input", "a", None) with tempfile.TemporaryDirectory() as tmpdirname:
self.assertEqual(to_save, 'a') to_save = dropdown_input.save_flagged(tmpdirname, "dropdown_input", "a", None)
restored = dropdown_input.restore_flagged(to_save) self.assertEqual(to_save, 'a')
self.assertEqual(restored, "a") restored = dropdown_input.restore_flagged(to_save)
self.assertEqual(restored, "a")
self.assertIsInstance(dropdown_input.generate_sample(), str) self.assertIsInstance(dropdown_input.generate_sample(), str)
dropdown_input = gr.inputs.Dropdown(choices=["a", "b", "c"], default="a", dropdown_input = gr.inputs.Dropdown(choices=["a", "b", "c"], default="a",
label="Drop Your Input") label="Drop Your Input")
@ -274,13 +282,14 @@ class TestImage(unittest.TestCase):
self.assertEqual(image_input.preprocess(img).size, (30, 10)) self.assertEqual(image_input.preprocess(img).size, (30, 10))
self.assertEqual(image_input.preprocess_example("test/test_files/bus.png"), img) self.assertEqual(image_input.preprocess_example("test/test_files/bus.png"), img)
self.assertEqual(image_input.serialize("test/test_files/bus.png", True), img) self.assertEqual(image_input.serialize("test/test_files/bus.png", True), img)
to_save = image_input.save_flagged("flagged", "image_input", img, None) with tempfile.TemporaryDirectory() as tmpdirname:
self.assertEqual("image_input/0.png", to_save) to_save = image_input.save_flagged(tmpdirname, "image_input", img, None)
to_save = image_input.save_flagged("flagged", "image_input", img, None) self.assertEqual("image_input/0.png", to_save)
self.assertEqual("image_input/1.png", to_save) to_save = image_input.save_flagged(tmpdirname, "image_input", img, None)
restored = image_input.restore_flagged(to_save) self.assertEqual("image_input/1.png", to_save)
self.assertEqual(restored, "image_input/1.png") restored = image_input.restore_flagged(to_save)
shutil.rmtree('flagged') self.assertEqual(restored, "image_input/1.png")
self.assertIsInstance(image_input.generate_sample(), str) self.assertIsInstance(image_input.generate_sample(), str)
image_input = gr.inputs.Image(source="upload", tool="editor", type="pil", label="Upload Your Image") image_input = gr.inputs.Image(source="upload", tool="editor", type="pil", label="Upload Your Image")
self.assertEqual(image_input.get_template_context(), { self.assertEqual(image_input.get_template_context(), {
@ -346,13 +355,15 @@ class TestAudio(unittest.TestCase):
self.assertEqual(output[1].shape, (8046,)) self.assertEqual(output[1].shape, (8046,))
self.assertEqual(audio_input.preprocess_example("test/test_files/audio_sample.wav"), x_wav["data"]) self.assertEqual(audio_input.preprocess_example("test/test_files/audio_sample.wav"), x_wav["data"])
self.assertEqual(audio_input.serialize("test/test_files/audio_sample.wav", True)["data"], x_wav["data"]) self.assertEqual(audio_input.serialize("test/test_files/audio_sample.wav", True)["data"], x_wav["data"])
to_save = audio_input.save_flagged("flagged", "audio_input", x_wav, None)
self.assertEqual("audio_input/0.wav", to_save) with tempfile.TemporaryDirectory() as tmpdirname:
to_save = audio_input.save_flagged("flagged", "audio_input", x_wav, None) to_save = audio_input.save_flagged(tmpdirname, "audio_input", x_wav, None)
self.assertEqual("audio_input/1.wav", to_save) self.assertEqual("audio_input/0.wav", to_save)
restored = audio_input.restore_flagged(to_save) to_save = audio_input.save_flagged(tmpdirname, "audio_input", x_wav, None)
self.assertEqual(restored, "audio_input/1.wav") self.assertEqual("audio_input/1.wav", to_save)
shutil.rmtree('flagged') restored = audio_input.restore_flagged(to_save)
self.assertEqual(restored, "audio_input/1.wav")
self.assertIsInstance(audio_input.generate_sample(), dict) self.assertIsInstance(audio_input.generate_sample(), dict)
audio_input = gr.inputs.Audio(label="Upload Your Audio") audio_input = gr.inputs.Audio(label="Upload Your Audio")
self.assertEqual(audio_input.get_template_context(), { self.assertEqual(audio_input.get_template_context(), {
@ -381,21 +392,21 @@ class TestAudio(unittest.TestCase):
self.assertIsInstance(audio_input.serialize(x_wav, False), dict) self.assertIsInstance(audio_input.serialize(x_wav, False), dict)
def test_in_interface(self): # def test_in_interface(self):
x_wav = gr.test_data.BASE64_AUDIO # x_wav = gr.test_data.BASE64_AUDIO
# def max_amplitude_from_wav_file(wav_file):
def max_amplitude_from_wav_file(wav_file): # audio_segment = AudioSegment.from_file(wav_file.name)
audio_segment = AudioSegment.from_file(wav_file.name) # data = np.array(audio_segment.get_array_of_samples())
data = np.array(audio_segment.get_array_of_samples()) # return np.max(data)
return np.max(data) # iface = gr.Interface(
iface = gr.Interface( # max_amplitude_from_wav_file,
max_amplitude_from_wav_file, # gr.inputs.Audio(type="file"),
gr.inputs.Audio(type="file"), # "number", interpretation="default")
"number", interpretation="default") # # TODO(aliabd): investigate why this sometimes fails (returns 5239 or 576)
self.assertEqual(iface.process([x_wav])[0], [576]) # self.assertEqual(iface.process([x_wav])[0], [576])
# scores, alternative_outputs = iface.interpret([x_wav]) # scores, alternative_outputs = iface.interpret([x_wav])
# self.assertEqual(scores, ... ) # self.assertEqual(scores, ... )
# self.assertEqual(alternative_outputs, ...) # self.assertEqual(alternative_outputs, ...)
class TestFile(unittest.TestCase): class TestFile(unittest.TestCase):
@ -406,13 +417,15 @@ class TestFile(unittest.TestCase):
self.assertIsInstance(output, tempfile._TemporaryFileWrapper) self.assertIsInstance(output, tempfile._TemporaryFileWrapper)
self.assertEqual(file_input.preprocess_example(x_file), x_file) self.assertEqual(file_input.preprocess_example(x_file), x_file)
self.assertEqual(file_input.serialize("test/test_files/sample_file.pdf", True), 'test/test_files/sample_file.pdf') self.assertEqual(file_input.serialize("test/test_files/sample_file.pdf", True), 'test/test_files/sample_file.pdf')
to_save = file_input.save_flagged("flagged", "file_input", [x_file], None)
self.assertEqual("file_input/0.pdf", to_save) with tempfile.TemporaryDirectory() as tmpdirname:
to_save = file_input.save_flagged("flagged", "file_input", [x_file], None) to_save = file_input.save_flagged(tmpdirname, "file_input", [x_file], None)
self.assertEqual("file_input/1.pdf", to_save) self.assertEqual("file_input/0.pdf", to_save)
restored = file_input.restore_flagged(to_save) to_save = file_input.save_flagged(tmpdirname, "file_input", [x_file], None)
self.assertEqual(restored, "file_input/1.pdf") self.assertEqual("file_input/1.pdf", to_save)
shutil.rmtree('flagged') restored = file_input.restore_flagged(to_save)
self.assertEqual(restored, "file_input/1.pdf")
self.assertIsInstance(file_input.generate_sample(), dict) self.assertIsInstance(file_input.generate_sample(), dict)
file_input = gr.inputs.File(label="Upload Your File") file_input = gr.inputs.File(label="Upload Your File")
self.assertEqual(file_input.get_template_context(), { self.assertEqual(file_input.get_template_context(), {
@ -444,10 +457,13 @@ class TestDataframe(unittest.TestCase):
self.assertEqual(output["Member"][0], False) self.assertEqual(output["Member"][0], False)
self.assertEqual(dataframe_input.preprocess_example(x_data), x_data) self.assertEqual(dataframe_input.preprocess_example(x_data), x_data)
self.assertEqual(dataframe_input.serialize(x_data, True), x_data) self.assertEqual(dataframe_input.serialize(x_data, True), x_data)
to_save = dataframe_input.save_flagged("flagged", "dataframe_input", x_data, None)
self.assertEqual(json.dumps(x_data), to_save) with tempfile.TemporaryDirectory() as tmpdirname:
restored = dataframe_input.restore_flagged(to_save) to_save = dataframe_input.save_flagged(tmpdirname, "dataframe_input", x_data, None)
self.assertEqual(x_data, restored) self.assertEqual(json.dumps(x_data), to_save)
restored = dataframe_input.restore_flagged(to_save)
self.assertEqual(x_data, restored)
self.assertIsInstance(dataframe_input.generate_sample(), list) self.assertIsInstance(dataframe_input.generate_sample(), list)
dataframe_input = gr.inputs.Dataframe(headers=["Name", "Age", "Member"], label="Dataframe Input") dataframe_input = gr.inputs.Dataframe(headers=["Name", "Age", "Member"], label="Dataframe Input")
self.assertEqual(dataframe_input.get_template_context(), { self.assertEqual(dataframe_input.get_template_context(), {
@ -486,13 +502,15 @@ class TestVideo(unittest.TestCase):
output = video_input.preprocess(x_video) output = video_input.preprocess(x_video)
self.assertIsInstance(output, str) self.assertIsInstance(output, str)
self.assertEqual(video_input.preprocess_example("test/test_files/video_sample.mp4"), x_video["data"]) self.assertEqual(video_input.preprocess_example("test/test_files/video_sample.mp4"), x_video["data"])
to_save = video_input.save_flagged("flagged", "video_input", x_video, None)
self.assertEqual("video_input/0.mp4", to_save) with tempfile.TemporaryDirectory() as tmpdirname:
to_save = video_input.save_flagged("flagged", "video_input", x_video, None) to_save = video_input.save_flagged(tmpdirname, "video_input", x_video, None)
self.assertEqual("video_input/1.mp4", to_save) self.assertEqual("video_input/0.mp4", to_save)
restored = video_input.restore_flagged(to_save) to_save = video_input.save_flagged(tmpdirname, "video_input", x_video, None)
self.assertEqual(restored, "video_input/1.mp4") self.assertEqual("video_input/1.mp4", to_save)
shutil.rmtree('flagged') restored = video_input.restore_flagged(to_save)
self.assertEqual(restored, "video_input/1.mp4")
self.assertIsInstance(video_input.generate_sample(), dict) self.assertIsInstance(video_input.generate_sample(), dict)
video_input = gr.inputs.Video(label="Upload Your Video") video_input = gr.inputs.Video(label="Upload Your Video")
self.assertEqual(video_input.get_template_context(), { self.assertEqual(video_input.get_template_context(), {
@ -529,10 +547,13 @@ class TestTimeseries(unittest.TestCase):
output = timeseries_input.preprocess(x_timeseries) output = timeseries_input.preprocess(x_timeseries)
self.assertIsInstance(output, pandas.core.frame.DataFrame) self.assertIsInstance(output, pandas.core.frame.DataFrame)
self.assertEqual(timeseries_input.preprocess_example(x_timeseries), x_timeseries) self.assertEqual(timeseries_input.preprocess_example(x_timeseries), x_timeseries)
to_save = timeseries_input.save_flagged("flagged", "video_input", x_timeseries, None)
self.assertEqual(json.dumps(x_timeseries), to_save) with tempfile.TemporaryDirectory() as tmpdirname:
restored = timeseries_input.restore_flagged(to_save) to_save = timeseries_input.save_flagged(tmpdirname, "video_input", x_timeseries, None)
self.assertEqual(x_timeseries, restored) self.assertEqual(json.dumps(x_timeseries), to_save)
restored = timeseries_input.restore_flagged(to_save)
self.assertEqual(x_timeseries, restored)
self.assertIsInstance(timeseries_input.generate_sample(), dict) self.assertIsInstance(timeseries_input.generate_sample(), dict)
timeseries_input = gr.inputs.Timeseries( timeseries_input = gr.inputs.Timeseries(
x="time", x="time",

110
test/test_outputs.py
View File

@ -3,7 +3,7 @@ import gradio as gr
import numpy as np import numpy as np
import pandas as pd import pandas as pd
import matplotlib.pyplot as plt import matplotlib.pyplot as plt
import shutil import tempfile
class OutputComponent(unittest.TestCase): class OutputComponent(unittest.TestCase):
@ -34,13 +34,14 @@ class TestLabel(unittest.TestCase):
self.assertDictEqual(label, {"label": "happy"}) self.assertDictEqual(label, {"label": "happy"})
self.assertEqual(label_output.deserialize(y), y) self.assertEqual(label_output.deserialize(y), y)
self.assertEqual(label_output.deserialize(label), y) self.assertEqual(label_output.deserialize(label), y)
to_save = label_output.save_flagged("flagged", "label_output", label, None) with tempfile.TemporaryDirectory() as tmpdir:
self.assertEqual(to_save, y) to_save = label_output.save_flagged(tmpdir, "label_output", label, None)
y = { self.assertEqual(to_save, y)
3: 0.7, y = {
1: 0.2, 3: 0.7,
0: 0.1 1: 0.2,
} 0: 0.1
}
label_output = gr.outputs.Label() label_output = gr.outputs.Label()
label = label_output.postprocess(y) label = label_output.postprocess(y)
self.assertDictEqual(label, { self.assertDictEqual(label, {
@ -63,9 +64,10 @@ class TestLabel(unittest.TestCase):
with self.assertRaises(ValueError): with self.assertRaises(ValueError):
label_output.postprocess([1, 2, 3]) label_output.postprocess([1, 2, 3])
to_save = label_output.save_flagged("flagged", "label_output", label, None) with tempfile.TemporaryDirectory() as tmpdir:
self.assertEqual(to_save, '{"3": 0.7, "1": 0.2}') to_save = label_output.save_flagged(tmpdir, "label_output", label, None)
self.assertEqual(label_output.restore_flagged(to_save), {"3": 0.7, "1": 0.2}) self.assertEqual(to_save, '{"3": 0.7, "1": 0.2}')
self.assertEqual(label_output.restore_flagged(to_save), {"3": 0.7, "1": 0.2})
with self.assertRaises(ValueError): with self.assertRaises(ValueError):
label_output = gr.outputs.Label(type="unknown") label_output = gr.outputs.Label(type="unknown")
label_output.deserialize([1, 2, 3]) label_output.deserialize([1, 2, 3])
@ -113,11 +115,11 @@ class TestImage(unittest.TestCase):
image_output.postprocess([1, 2, 3]) image_output.postprocess([1, 2, 3])
image_output = gr.outputs.Image(type="numpy") image_output = gr.outputs.Image(type="numpy")
self.assertTrue(image_output.postprocess(y_img).startswith("data:image/png;base64,")) self.assertTrue(image_output.postprocess(y_img).startswith("data:image/png;base64,"))
to_save = image_output.save_flagged("flagged", "image_output", gr.test_data.BASE64_IMAGE, None) with tempfile.TemporaryDirectory() as tmpdirname:
self.assertEqual("image_output/0.png", to_save) to_save = image_output.save_flagged(tmpdirname, "image_output", gr.test_data.BASE64_IMAGE, None)
to_save = image_output.save_flagged("flagged", "image_output", gr.test_data.BASE64_IMAGE, None) self.assertEqual("image_output/0.png", to_save)
self.assertEqual("image_output/1.png", to_save) to_save = image_output.save_flagged(tmpdirname, "image_output", gr.test_data.BASE64_IMAGE, None)
shutil.rmtree('flagged') self.assertEqual("image_output/1.png", to_save)
def test_in_interface(self): def test_in_interface(self):
def generate_noise(width, height): def generate_noise(width, height):
@ -133,11 +135,11 @@ class TestVideo(unittest.TestCase):
video_output = gr.outputs.Video() video_output = gr.outputs.Video()
self.assertTrue(video_output.postprocess(y_vid)["data"].startswith("data:video/mp4;base64,")) self.assertTrue(video_output.postprocess(y_vid)["data"].startswith("data:video/mp4;base64,"))
self.assertTrue(video_output.deserialize(gr.test_data.BASE64_VIDEO["data"]).endswith(".mp4")) self.assertTrue(video_output.deserialize(gr.test_data.BASE64_VIDEO["data"]).endswith(".mp4"))
to_save = video_output.save_flagged("flagged", "video_output", gr.test_data.BASE64_VIDEO, None) with tempfile.TemporaryDirectory() as tmpdirname:
self.assertEqual("video_output/0.mp4", to_save) to_save = video_output.save_flagged(tmpdirname, "video_output", gr.test_data.BASE64_VIDEO, None)
to_save = video_output.save_flagged("flagged", "video_output", gr.test_data.BASE64_VIDEO, None) self.assertEqual("video_output/0.mp4", to_save)
self.assertEqual("video_output/1.mp4", to_save) to_save = video_output.save_flagged(tmpdirname, "video_output", gr.test_data.BASE64_VIDEO, None)
shutil.rmtree('flagged') self.assertEqual("video_output/1.mp4", to_save)
class TestKeyValues(unittest.TestCase): class TestKeyValues(unittest.TestCase):
@ -149,9 +151,10 @@ class TestKeyValues(unittest.TestCase):
self.assertEqual(kv_output.postprocess(kv_list), kv_list) self.assertEqual(kv_output.postprocess(kv_list), kv_list)
with self.assertRaises(ValueError): with self.assertRaises(ValueError):
kv_output.postprocess(0) kv_output.postprocess(0)
to_save = kv_output.save_flagged("flagged", "kv_output", kv_list, None) with tempfile.TemporaryDirectory() as tmpdirname:
self.assertEqual(to_save, '[["a", 1], ["b", 2]]') to_save = kv_output.save_flagged(tmpdirname, "kv_output", kv_list, None)
self.assertEqual(kv_output.restore_flagged(to_save), [["a", 1], ["b", 2]]) self.assertEqual(to_save, '[["a", 1], ["b", 2]]')
self.assertEqual(kv_output.restore_flagged(to_save), [["a", 1], ["b", 2]])
def test_in_interface(self): def test_in_interface(self):
def letter_distribution(word): def letter_distribution(word):
@ -177,9 +180,10 @@ class TestHighlightedText(unittest.TestCase):
"pos": "Hello ", "pos": "Hello ",
"neg": "World" "neg": "World"
} }
to_save = ht_output.save_flagged("flagged", "ht_output", ht, None) with tempfile.TemporaryDirectory() as tmpdirname:
self.assertEqual(to_save, '{"pos": "Hello ", "neg": "World"}') to_save = ht_output.save_flagged(tmpdirname, "ht_output", ht, None)
self.assertEqual(ht_output.restore_flagged(to_save), {"pos": "Hello ", "neg": "World"}) self.assertEqual(to_save, '{"pos": "Hello ", "neg": "World"}')
self.assertEqual(ht_output.restore_flagged(to_save), {"pos": "Hello ", "neg": "World"})
def test_in_interface(self): def test_in_interface(self):
def highlight_vowels(sentence): def highlight_vowels(sentence):
@ -215,11 +219,11 @@ class TestAudio(unittest.TestCase):
wrong_type = gr.outputs.Audio(type="unknown") wrong_type = gr.outputs.Audio(type="unknown")
wrong_type.postprocess(y_audio.name) wrong_type.postprocess(y_audio.name)
self.assertTrue(audio_output.deserialize(gr.test_data.BASE64_AUDIO["data"]).endswith(".wav")) self.assertTrue(audio_output.deserialize(gr.test_data.BASE64_AUDIO["data"]).endswith(".wav"))
to_save = audio_output.save_flagged("flagged", "audio_output", gr.test_data.BASE64_AUDIO["data"], None) with tempfile.TemporaryDirectory() as tmpdirname:
self.assertEqual("audio_output/0.wav", to_save) to_save = audio_output.save_flagged(tmpdirname, "audio_output", gr.test_data.BASE64_AUDIO["data"], None)
to_save = audio_output.save_flagged("flagged", "audio_output", gr.test_data.BASE64_AUDIO["data"], None) self.assertEqual("audio_output/0.wav", to_save)
self.assertEqual("audio_output/1.wav", to_save) to_save = audio_output.save_flagged(tmpdirname, "audio_output", gr.test_data.BASE64_AUDIO["data"], None)
shutil.rmtree('flagged') self.assertEqual("audio_output/1.wav", to_save)
def test_in_interface(self): def test_in_interface(self):
def generate_noise(duration): def generate_noise(duration):
@ -237,9 +241,10 @@ class TestJSON(unittest.TestCase):
"pos": "Hello ", "pos": "Hello ",
"neg": "World" "neg": "World"
} }
to_save = js_output.save_flagged("flagged", "js_output", js, None) with tempfile.TemporaryDirectory() as tmpdirname:
self.assertEqual(to_save, '{"pos": "Hello ", "neg": "World"}') to_save = js_output.save_flagged(tmpdirname, "js_output", js, None)
self.assertEqual(js_output.restore_flagged(to_save), {"pos": "Hello ", "neg": "World"}) self.assertEqual(to_save, '{"pos": "Hello ", "neg": "World"}')
self.assertEqual(js_output.restore_flagged(to_save), {"pos": "Hello ", "neg": "World"})
def test_in_interface(self): def test_in_interface(self):
def get_avg_age_per_gender(data): def get_avg_age_per_gender(data):
@ -286,11 +291,11 @@ class TestFile(unittest.TestCase):
'name': 'test.txt', 'size': 11, 'data': 'aGVsbG8gd29ybGQ=' 'name': 'test.txt', 'size': 11, 'data': 'aGVsbG8gd29ybGQ='
}) })
file_output = gr.outputs.File() file_output = gr.outputs.File()
to_save = file_output.save_flagged("flagged", "file_output", gr.test_data.BASE64_FILE, None) with tempfile.TemporaryDirectory() as tmpdirname:
self.assertEqual("file_output/0.pdf", to_save) to_save = file_output.save_flagged(tmpdirname, "file_output", gr.test_data.BASE64_FILE, None)
to_save = file_output.save_flagged("flagged", "file_output", gr.test_data.BASE64_FILE, None) self.assertEqual("file_output/0.pdf", to_save)
self.assertEqual("file_output/1.pdf", to_save) to_save = file_output.save_flagged(tmpdirname, "file_output", gr.test_data.BASE64_FILE, None)
shutil.rmtree('flagged') self.assertEqual("file_output/1.pdf", to_save)
class TestDataframe(unittest.TestCase): class TestDataframe(unittest.TestCase):
@ -315,9 +320,10 @@ class TestDataframe(unittest.TestCase):
with self.assertRaises(ValueError): with self.assertRaises(ValueError):
wrong_type = gr.outputs.Dataframe(type="unknown") wrong_type = gr.outputs.Dataframe(type="unknown")
wrong_type.postprocess(0) wrong_type.postprocess(0)
to_save = dataframe_output.save_flagged("flagged", "dataframe_output", output, None) with tempfile.TemporaryDirectory() as tmpdirname:
self.assertEqual(to_save, '[[2, true], [3, true], [4, false]]') to_save = dataframe_output.save_flagged(tmpdirname, "dataframe_output", output, None)
self.assertEqual(dataframe_output.restore_flagged(to_save), [[2, True], [3, True], [4, False]]) self.assertEqual(to_save, '[[2, true], [3, true], [4, false]]')
self.assertEqual(dataframe_output.restore_flagged(to_save), [[2, True], [3, True], [4, False]])
def test_in_interface(self): def test_in_interface(self):
def check_odd(array): def check_odd(array):
@ -349,8 +355,9 @@ class TestCarousel(unittest.TestCase):
self.assertEqual(output, [['Hello World'], ['Bye World']]) self.assertEqual(output, [['Hello World'], ['Bye World']])
with self.assertRaises(ValueError): with self.assertRaises(ValueError):
carousel_output.postprocess('Hello World!') carousel_output.postprocess('Hello World!')
to_save = carousel_output.save_flagged("flagged", "carousel_output", output, None) with tempfile.TemporaryDirectory() as tmpdirname:
self.assertEqual(to_save, '[["Hello World"], ["Bye World"]]') to_save = carousel_output.save_flagged(tmpdirname, "carousel_output", output, None)
self.assertEqual(to_save, '[["Hello World"], ["Bye World"]]')
def test_in_interface(self): def test_in_interface(self):
carousel_output = gr.outputs.Carousel(["text", "image"], label="Disease") carousel_output = gr.outputs.Carousel(["text", "image"], label="Disease")
@ -389,12 +396,13 @@ class TestTimeseries(unittest.TestCase):
'data': [['Tom', 20], ['nick', 21], ['krish', 19], 'data': [['Tom', 20], ['nick', 21], ['krish', 19],
['jack', 18]]}) ['jack', 18]]})
to_save = timeseries_output.save_flagged("flagged", "timeseries_output", output, None) with tempfile.TemporaryDirectory() as tmpdirname:
self.assertEqual(to_save, '{"headers": ["Name", "Age"], "data": [["Tom", 20], ["nick", 21], ["krish", 19], ' to_save = timeseries_output.save_flagged(tmpdirname, "timeseries_output", output, None)
'["jack", 18]]}') self.assertEqual(to_save, '{"headers": ["Name", "Age"], "data": [["Tom", 20], ["nick", 21], ["krish", 19], '
self.assertEqual(timeseries_output.restore_flagged(to_save), {"headers": ["Name", "Age"], '["jack", 18]]}')
"data": [["Tom", 20], ["nick", 21], self.assertEqual(timeseries_output.restore_flagged(to_save), {"headers": ["Name", "Age"],
["krish", 19], ["jack", 18]]}) "data": [["Tom", 20], ["nick", 21],
["krish", 19], ["jack", 18]]})
class TestNames(unittest.TestCase): class TestNames(unittest.TestCase):