mirror of
https://github.com/gradio-app/gradio.git
synced 2024-12-21 02:19:59 +08:00
Merge branch 'blocks-dev' into 862-chatbot
This commit is contained in:
Abubakar Abid
commit
508c28bde0
@ -11,12 +11,12 @@ import warnings
|
||||
from types import ModuleType
|
||||
from typing import Any, Callable, Dict, List, Optional, Tuple
|
||||
|
||||
import matplotlib.figure
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
import PIL
|
||||
from ffmpy import FFmpeg
|
||||
from markdown_it import MarkdownIt
|
||||
import matplotlib.figure
|
||||
|
||||
from gradio import processing_utils, test_data
|
||||
from gradio.blocks import Block
|
||||
@ -2097,6 +2097,8 @@ class Dataframe(Component):
|
||||
dtype = "numpy"
|
||||
elif isinstance(y, list):
|
||||
dtype = "array"
|
||||
else:
|
||||
raise ValueError("Cannot determine the type of DataFrame output.")
|
||||
else:
|
||||
dtype = self.output_type
|
||||
if dtype == "pandas":
|
||||
@ -2778,7 +2780,7 @@ class DatasetViewer(Component):
|
||||
|
||||
def get_template_context(self):
|
||||
return {
|
||||
"types": [_type.__class__.__name__.lower() for _type in types],
|
||||
"types": [_type.__class__.__name__.lower() for _type in self.types],
|
||||
"value": self.value,
|
||||
**super().get_template_context(),
|
||||
}
|
||||
|
||||
@ -171,7 +171,7 @@ class CheckboxGroup(C_CheckboxGroup):
|
||||
DeprecationWarning,
|
||||
)
|
||||
super().__init__(
|
||||
default_value=default,
|
||||
default_selected=default,
|
||||
choices=choices,
|
||||
type=type,
|
||||
label=label,
|
||||
@ -209,7 +209,7 @@ class Radio(C_Radio):
|
||||
super().__init__(
|
||||
choices=choices,
|
||||
type=type,
|
||||
default_value=default,
|
||||
default_selected=default,
|
||||
label=label,
|
||||
optional=optional,
|
||||
)
|
||||
@ -245,7 +245,7 @@ class Dropdown(C_Dropdown):
|
||||
super().__init__(
|
||||
choices=choices,
|
||||
type=type,
|
||||
default_value=default,
|
||||
default_selected=default,
|
||||
label=label,
|
||||
optional=optional,
|
||||
)
|
||||
|
||||
@ -615,34 +615,6 @@ class Interface(Launchable):
|
||||
else:
|
||||
return predictions
|
||||
|
||||
def process_api(self, data: Dict[str, Any], username: str = None) -> Dict[str, Any]:
|
||||
flag_index = None
|
||||
if data.get("example_id") is not None:
|
||||
example_id = data["example_id"]
|
||||
if self.cache_examples:
|
||||
prediction = load_from_cache(self, example_id)
|
||||
durations = None
|
||||
else:
|
||||
prediction, durations = process_example(self, example_id)
|
||||
else:
|
||||
raw_input = data["data"]
|
||||
prediction, durations = self.process(raw_input)
|
||||
if self.allow_flagging == "auto":
|
||||
flag_index = self.flagging_callback.flag(
|
||||
self,
|
||||
raw_input,
|
||||
prediction,
|
||||
flag_option="" if self.flagging_options else None,
|
||||
username=username,
|
||||
)
|
||||
|
||||
return {
|
||||
"data": prediction,
|
||||
"durations": durations,
|
||||
"avg_durations": self.config.get("avg_durations"),
|
||||
"flag_index": flag_index,
|
||||
}
|
||||
|
||||
def process_api(self, data: Dict[str, Any], username: str = None) -> Dict[str, Any]:
|
||||
class RequestApi:
|
||||
SUBMIT = 0
|
||||
|
||||
@ -54,7 +54,7 @@ def cache_interface_examples(interface: Interface) -> None:
|
||||
def load_from_cache(interface: Interface, example_id: int) -> List[Any]:
|
||||
"""Loads a particular cached example for the interface."""
|
||||
with open(CACHE_FILE) as cache:
|
||||
examples = list(csv.reader(cache))
|
||||
examples = list(csv.reader(cache, quotechar="'"))
|
||||
example = examples[example_id + 1] # +1 to adjust for header
|
||||
output = []
|
||||
for component, cell in zip(interface.output_components, example):
|
||||
|
||||
@ -45,7 +45,7 @@
|
||||
</script>
|
||||
<script src="https://cdnjs.cloudflare.com/ajax/libs/iframe-resizer/4.3.1/iframeResizer.contentWindow.min.js"></script>
|
||||
<title>Gradio</title>
|
||||
<script type="module" crossorigin src="./assets/index.dfda4ad8.js"></script>
|
||||
<script type="module" crossorigin src="./assets/index.ea63c9ea.js"></script>
|
||||
<link rel="modulepreload" href="./assets/vendor.c988cbcf.js">
|
||||
<link rel="stylesheet" href="./assets/index.778d40cb.css">
|
||||
</head>
|
||||
|
||||
@ -1,9 +1,17 @@
|
||||
def test_context():
|
||||
from gradio.context import Context
|
||||
# import unittest
|
||||
|
||||
assert Context.id == 0
|
||||
Context.id += 1
|
||||
assert Context.id == 1
|
||||
Context.root_block = {}
|
||||
Context.root_block["1"] = 1
|
||||
assert Context.root_block == {"1": 1}
|
||||
# from gradio.context import Context
|
||||
|
||||
|
||||
# class TestContext(unittest.TestCase):
|
||||
# def test_context(self):
|
||||
# self.assertEqual(Context.id, 0)
|
||||
# Context.id += 1
|
||||
# self.assertEqual(Context.id, 1)
|
||||
# Context.root_block = {}
|
||||
# Context.root_block["1"] = 1
|
||||
# self.assertEqual(Context.root_block, {"1": 1})
|
||||
|
||||
|
||||
# if __name__ == "__main__":
|
||||
# unittest.main()
|
||||
|
||||
@ -1,261 +0,0 @@
|
||||
import multiprocessing
|
||||
import os
|
||||
import random
|
||||
import time
|
||||
import unittest
|
||||
|
||||
import requests
|
||||
from matplotlib.testing.compare import compare_images
|
||||
from selenium import webdriver
|
||||
from selenium.webdriver.common.by import By
|
||||
from selenium.webdriver.support import expected_conditions as EC
|
||||
from selenium.webdriver.support.ui import WebDriverWait
|
||||
|
||||
current_dir = os.getcwd()
|
||||
|
||||
LOCAL_HOST = "http://localhost:{}"
|
||||
GOLDEN_PATH = "test/golden/{}/{}.png"
|
||||
TOLERANCE = 0.1
|
||||
TIMEOUT = 10
|
||||
|
||||
GAP_TO_SCREENSHOT = 2
|
||||
|
||||
os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"
|
||||
|
||||
|
||||
def wait_for_url(url):
|
||||
for i in range(TIMEOUT):
|
||||
try:
|
||||
requests.get(url)
|
||||
print("Interface connected.")
|
||||
break
|
||||
except:
|
||||
time.sleep(0.2)
|
||||
else:
|
||||
raise ConnectionError("Could not connect to interface.")
|
||||
|
||||
|
||||
def diff_texts_thread(return_dict):
|
||||
from demo.diff_texts.run import iface
|
||||
|
||||
iface.save_to = return_dict
|
||||
iface.launch()
|
||||
|
||||
|
||||
def image_mod_thread(return_dict):
|
||||
from demo.image_mod.run import iface
|
||||
|
||||
iface.examples = None
|
||||
iface.save_to = return_dict
|
||||
iface.launch()
|
||||
|
||||
|
||||
def longest_word_thread(return_dict):
|
||||
from demo.longest_word.run import iface
|
||||
|
||||
iface.save_to = return_dict
|
||||
iface.launch()
|
||||
|
||||
|
||||
def sentence_builder_thread(return_dict):
|
||||
from demo.sentence_builder.run import iface
|
||||
|
||||
iface.save_to = return_dict
|
||||
iface.launch()
|
||||
|
||||
|
||||
class TestDemo(unittest.TestCase):
|
||||
def start_test(self, target):
|
||||
manager = multiprocessing.Manager()
|
||||
return_dict = manager.dict()
|
||||
self.i_thread = multiprocessing.Process(target=target, args=(return_dict,))
|
||||
self.i_thread.start()
|
||||
total_sleep = 0
|
||||
while not return_dict and total_sleep < TIMEOUT:
|
||||
time.sleep(0.2)
|
||||
total_sleep += 0.2
|
||||
URL = LOCAL_HOST.format(return_dict["port"])
|
||||
wait_for_url(URL)
|
||||
|
||||
driver = webdriver.Chrome()
|
||||
driver.set_window_size(1200, 800)
|
||||
driver.get(URL)
|
||||
return driver
|
||||
|
||||
def test_diff_texts(self):
|
||||
driver = self.start_test(target=diff_texts_thread)
|
||||
elem = WebDriverWait(driver, TIMEOUT).until(
|
||||
EC.presence_of_element_located(
|
||||
(
|
||||
By.CSS_SELECTOR,
|
||||
".panel:nth-child(1) .component:nth-child(1) .input-text",
|
||||
)
|
||||
)
|
||||
)
|
||||
elem.clear()
|
||||
elem.send_keys("Want to see a magic trick?")
|
||||
elem = WebDriverWait(driver, TIMEOUT).until(
|
||||
EC.presence_of_element_located(
|
||||
(
|
||||
By.CSS_SELECTOR,
|
||||
".panel:nth-child(1) .component:nth-child(2) .input-text",
|
||||
)
|
||||
)
|
||||
)
|
||||
elem.clear()
|
||||
elem.send_keys("Let's go see a magic trick!")
|
||||
elem = WebDriverWait(driver, TIMEOUT).until(
|
||||
EC.presence_of_element_located((By.CSS_SELECTOR, ".submit"))
|
||||
)
|
||||
elem.click()
|
||||
elem = WebDriverWait(driver, TIMEOUT).until(
|
||||
EC.presence_of_element_located(
|
||||
(
|
||||
By.CSS_SELECTOR,
|
||||
".panel:nth-child(2) .component:nth-child(2) .textfield",
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
total_sleep = 0
|
||||
while elem.text == "" and total_sleep < TIMEOUT:
|
||||
time.sleep(0.2)
|
||||
total_sleep += 0.2
|
||||
|
||||
self.assertEqual(
|
||||
elem.text,
|
||||
"L + e + W - a - n - t ' + s + t - g + o s e e a m a g i c t r i c k ? - ! +",
|
||||
)
|
||||
golden_img = os.path.join(
|
||||
current_dir, GOLDEN_PATH.format("diff_texts", "magic_trick")
|
||||
)
|
||||
tmp = os.path.join(
|
||||
current_dir, "test/tmp/{}.png".format(random.getrandbits(32))
|
||||
)
|
||||
time.sleep(GAP_TO_SCREENSHOT)
|
||||
driver.save_screenshot(tmp)
|
||||
driver.close()
|
||||
self.assertIsNone(compare_images(tmp, golden_img, TOLERANCE))
|
||||
os.remove(tmp)
|
||||
|
||||
def test_image_mod(self):
|
||||
driver = self.start_test(target=image_mod_thread)
|
||||
elem = WebDriverWait(driver, TIMEOUT).until(
|
||||
EC.presence_of_element_located(
|
||||
(
|
||||
By.CSS_SELECTOR,
|
||||
".panel:nth-child(1) .component:nth-child(1) .hidden-upload",
|
||||
)
|
||||
)
|
||||
)
|
||||
cwd = os.getcwd()
|
||||
rel = "test/test_files/cheetah1.jpg"
|
||||
elem.send_keys(os.path.join(cwd, rel))
|
||||
golden_img = os.path.join(
|
||||
current_dir, GOLDEN_PATH.format("image_mod", "cheetah1")
|
||||
)
|
||||
tmp = os.path.join(
|
||||
current_dir, "test/tmp/{}.png".format(random.getrandbits(32))
|
||||
)
|
||||
elem = WebDriverWait(driver, TIMEOUT).until(
|
||||
EC.presence_of_element_located((By.CSS_SELECTOR, ".submit"))
|
||||
)
|
||||
elem.click()
|
||||
WebDriverWait(driver, TIMEOUT).until(
|
||||
EC.visibility_of_element_located(
|
||||
(
|
||||
By.CSS_SELECTOR,
|
||||
".panel:nth-child(2) .component:nth-child(2) .output-image",
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
time.sleep(GAP_TO_SCREENSHOT)
|
||||
driver.save_screenshot(tmp)
|
||||
self.assertIsNone(compare_images(tmp, golden_img, TOLERANCE))
|
||||
os.remove(tmp)
|
||||
driver.close()
|
||||
|
||||
def test_longest_word(self):
|
||||
driver = self.start_test(target=longest_word_thread)
|
||||
elem = WebDriverWait(driver, TIMEOUT).until(
|
||||
EC.presence_of_element_located(
|
||||
(
|
||||
By.CSS_SELECTOR,
|
||||
".panel:nth-child(1) .component:nth-child(1) .input-text",
|
||||
)
|
||||
)
|
||||
)
|
||||
elem.send_keys("This is the most wonderful machine learning " "library.")
|
||||
elem = WebDriverWait(driver, TIMEOUT).until(
|
||||
EC.presence_of_element_located((By.CSS_SELECTOR, ".submit"))
|
||||
)
|
||||
elem.click()
|
||||
elem = WebDriverWait(driver, TIMEOUT).until(
|
||||
EC.presence_of_element_located(
|
||||
(
|
||||
By.CSS_SELECTOR,
|
||||
".panel:nth-child(2) .component:nth-child(2) .output-class",
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
total_sleep = 0
|
||||
while elem.text == "" and total_sleep < TIMEOUT:
|
||||
time.sleep(0.2)
|
||||
total_sleep += 0.2
|
||||
|
||||
golden_img = os.path.join(
|
||||
current_dir, GOLDEN_PATH.format("longest_word", "wonderful")
|
||||
)
|
||||
tmp = os.path.join(
|
||||
current_dir, "test/tmp/{}.png".format(random.getrandbits(32))
|
||||
)
|
||||
time.sleep(GAP_TO_SCREENSHOT)
|
||||
driver.save_screenshot(tmp)
|
||||
driver.close()
|
||||
self.assertIsNone(compare_images(tmp, golden_img, TOLERANCE))
|
||||
os.remove(tmp)
|
||||
|
||||
def test_sentence_builder(self):
|
||||
driver = self.start_test(target=sentence_builder_thread)
|
||||
elem = WebDriverWait(driver, TIMEOUT).until(
|
||||
EC.presence_of_element_located((By.CSS_SELECTOR, ".submit"))
|
||||
)
|
||||
elem.click()
|
||||
elem = WebDriverWait(driver, TIMEOUT).until(
|
||||
EC.presence_of_element_located(
|
||||
(
|
||||
By.CSS_SELECTOR,
|
||||
".panel:nth-child(2) .component:nth-child(2) .output-text",
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
total_sleep = 0
|
||||
while elem.text == "" and total_sleep < TIMEOUT:
|
||||
time.sleep(0.2)
|
||||
total_sleep += 0.2
|
||||
|
||||
self.assertEqual(
|
||||
elem.text, "The 2 cats went to the park where they until the night"
|
||||
)
|
||||
golden_img = os.path.join(
|
||||
current_dir, GOLDEN_PATH.format("sentence_builder", "two_cats")
|
||||
)
|
||||
tmp = os.path.join(
|
||||
current_dir, "test/tmp/{}.png".format(random.getrandbits(32))
|
||||
)
|
||||
time.sleep(GAP_TO_SCREENSHOT)
|
||||
driver.save_screenshot(tmp)
|
||||
self.assertIsNone(compare_images(tmp, golden_img, TOLERANCE))
|
||||
os.remove(tmp)
|
||||
driver.close()
|
||||
|
||||
def tearDown(self):
|
||||
self.i_thread.terminate()
|
||||
self.i_thread.join()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@ -11,12 +11,12 @@ class TestKeyGenerator(unittest.TestCase):
|
||||
def test_same_pass(self):
|
||||
key1 = encryptor.get_key("test")
|
||||
key2 = encryptor.get_key("test")
|
||||
self.assertEquals(key1, key2)
|
||||
self.assertEqual(key1, key2)
|
||||
|
||||
def test_diff_pass(self):
|
||||
key1 = encryptor.get_key("test")
|
||||
key2 = encryptor.get_key("diff_test")
|
||||
self.assertNotEquals(key1, key2)
|
||||
self.assertNotEqual(key1, key2)
|
||||
|
||||
|
||||
class TestEncryptorDecryptor(unittest.TestCase):
|
||||
@ -25,7 +25,7 @@ class TestEncryptorDecryptor(unittest.TestCase):
|
||||
data, _ = processing_utils.decode_base64_to_binary(BASE64_IMAGE)
|
||||
encrypted_data = encryptor.encrypt(key, data)
|
||||
decrypted_data = encryptor.decrypt(key, encrypted_data)
|
||||
self.assertEquals(data, decrypted_data)
|
||||
self.assertEqual(data, decrypted_data)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
@ -1,253 +1,253 @@
|
||||
import os
|
||||
import pathlib
|
||||
import unittest
|
||||
# import os
|
||||
# import pathlib
|
||||
# import unittest
|
||||
|
||||
import transformers
|
||||
# import transformers
|
||||
|
||||
import gradio as gr
|
||||
# import gradio as gr
|
||||
|
||||
"""
|
||||
WARNING: These tests have an external dependency: namely that Hugging Face's
|
||||
Hub and Space APIs do not change, and they keep their most famous models up.
|
||||
So if, e.g. Spaces is down, then these test will not pass.
|
||||
"""
|
||||
# """
|
||||
# WARNING: These tests have an external dependency: namely that Hugging Face's
|
||||
# Hub and Space APIs do not change, and they keep their most famous models up.
|
||||
# So if, e.g. Spaces is down, then these test will not pass.
|
||||
# """
|
||||
|
||||
os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"
|
||||
# os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"
|
||||
|
||||
|
||||
class TestHuggingFaceModelAPI(unittest.TestCase):
|
||||
def test_audio_to_audio(self):
|
||||
model_type = "audio-to-audio"
|
||||
interface_info = gr.external.get_huggingface_interface(
|
||||
"speechbrain/mtl-mimic-voicebank",
|
||||
api_key=None,
|
||||
alias=model_type,
|
||||
)
|
||||
self.assertEqual(interface_info["fn"].__name__, model_type)
|
||||
self.assertIsInstance(interface_info["inputs"], gr.components.Audio)
|
||||
self.assertIsInstance(interface_info["outputs"], gr.components.Audio)
|
||||
# class TestHuggingFaceModelAPI(unittest.TestCase):
|
||||
# def test_audio_to_audio(self):
|
||||
# model_type = "audio-to-audio"
|
||||
# interface_info = gr.external.get_huggingface_interface(
|
||||
# "speechbrain/mtl-mimic-voicebank",
|
||||
# api_key=None,
|
||||
# alias=model_type,
|
||||
# )
|
||||
# self.assertEqual(interface_info["fn"].__name__, model_type)
|
||||
# self.assertIsInstance(interface_info["inputs"], gr.components.Audio)
|
||||
# self.assertIsInstance(interface_info["outputs"], gr.components.Audio)
|
||||
|
||||
def test_question_answering(self):
|
||||
model_type = "question-answering"
|
||||
interface_info = gr.external.get_huggingface_interface(
|
||||
"lysandre/tiny-vit-random", api_key=None, alias=model_type
|
||||
)
|
||||
self.assertEqual(interface_info["fn"].__name__, model_type)
|
||||
self.assertIsInstance(interface_info["inputs"], gr.components.Image)
|
||||
self.assertIsInstance(interface_info["outputs"], gr.components.Label)
|
||||
# def test_question_answering(self):
|
||||
# model_type = "question-answering"
|
||||
# interface_info = gr.external.get_huggingface_interface(
|
||||
# "lysandre/tiny-vit-random", api_key=None, alias=model_type
|
||||
# )
|
||||
# self.assertEqual(interface_info["fn"].__name__, model_type)
|
||||
# self.assertIsInstance(interface_info["inputs"], gr.components.Image)
|
||||
# self.assertIsInstance(interface_info["outputs"], gr.components.Label)
|
||||
|
||||
def test_text_generation(self):
|
||||
model_type = "text_generation"
|
||||
interface_info = gr.external.get_huggingface_interface(
|
||||
"gpt2", api_key=None, alias=model_type
|
||||
)
|
||||
self.assertEqual(interface_info["fn"].__name__, model_type)
|
||||
self.assertIsInstance(interface_info["inputs"], gr.components.Textbox)
|
||||
self.assertIsInstance(interface_info["outputs"], gr.components.Textbox)
|
||||
# def test_text_generation(self):
|
||||
# model_type = "text_generation"
|
||||
# interface_info = gr.external.get_huggingface_interface(
|
||||
# "gpt2", api_key=None, alias=model_type
|
||||
# )
|
||||
# self.assertEqual(interface_info["fn"].__name__, model_type)
|
||||
# self.assertIsInstance(interface_info["inputs"], gr.components.Textbox)
|
||||
# self.assertIsInstance(interface_info["outputs"], gr.components.Textbox)
|
||||
|
||||
def test_summarization(self):
|
||||
model_type = "summarization"
|
||||
interface_info = gr.external.get_huggingface_interface(
|
||||
"facebook/bart-large-cnn", api_key=None, alias=model_type
|
||||
)
|
||||
self.assertEqual(interface_info["fn"].__name__, model_type)
|
||||
self.assertIsInstance(interface_info["inputs"], gr.components.Textbox)
|
||||
self.assertIsInstance(interface_info["outputs"], gr.components.Textbox)
|
||||
# def test_summarization(self):
|
||||
# model_type = "summarization"
|
||||
# interface_info = gr.external.get_huggingface_interface(
|
||||
# "facebook/bart-large-cnn", api_key=None, alias=model_type
|
||||
# )
|
||||
# self.assertEqual(interface_info["fn"].__name__, model_type)
|
||||
# self.assertIsInstance(interface_info["inputs"], gr.components.Textbox)
|
||||
# self.assertIsInstance(interface_info["outputs"], gr.components.Textbox)
|
||||
|
||||
def test_translation(self):
|
||||
model_type = "translation"
|
||||
interface_info = gr.external.get_huggingface_interface(
|
||||
"facebook/bart-large-cnn", api_key=None, alias=model_type
|
||||
)
|
||||
self.assertEqual(interface_info["fn"].__name__, model_type)
|
||||
self.assertIsInstance(interface_info["inputs"], gr.components.Textbox)
|
||||
self.assertIsInstance(interface_info["outputs"], gr.components.Textbox)
|
||||
# def test_translation(self):
|
||||
# model_type = "translation"
|
||||
# interface_info = gr.external.get_huggingface_interface(
|
||||
# "facebook/bart-large-cnn", api_key=None, alias=model_type
|
||||
# )
|
||||
# self.assertEqual(interface_info["fn"].__name__, model_type)
|
||||
# self.assertIsInstance(interface_info["inputs"], gr.components.Textbox)
|
||||
# self.assertIsInstance(interface_info["outputs"], gr.components.Textbox)
|
||||
|
||||
def test_text2text_generation(self):
|
||||
model_type = "text2text-generation"
|
||||
interface_info = gr.external.get_huggingface_interface(
|
||||
"sshleifer/tiny-mbart", api_key=None, alias=model_type
|
||||
)
|
||||
self.assertEqual(interface_info["fn"].__name__, model_type)
|
||||
self.assertIsInstance(interface_info["inputs"], gr.components.Textbox)
|
||||
self.assertIsInstance(interface_info["outputs"], gr.components.Textbox)
|
||||
# def test_text2text_generation(self):
|
||||
# model_type = "text2text-generation"
|
||||
# interface_info = gr.external.get_huggingface_interface(
|
||||
# "sshleifer/tiny-mbart", api_key=None, alias=model_type
|
||||
# )
|
||||
# self.assertEqual(interface_info["fn"].__name__, model_type)
|
||||
# self.assertIsInstance(interface_info["inputs"], gr.components.Textbox)
|
||||
# self.assertIsInstance(interface_info["outputs"], gr.components.Textbox)
|
||||
|
||||
def test_text_classification(self):
|
||||
model_type = "text-classification"
|
||||
interface_info = gr.external.get_huggingface_interface(
|
||||
"distilbert-base-uncased-finetuned-sst-2-english",
|
||||
api_key=None,
|
||||
alias=model_type,
|
||||
)
|
||||
self.assertEqual(interface_info["fn"].__name__, model_type)
|
||||
self.assertIsInstance(interface_info["inputs"], gr.components.Textbox)
|
||||
self.assertIsInstance(interface_info["outputs"], gr.components.Label)
|
||||
# def test_text_classification(self):
|
||||
# model_type = "text-classification"
|
||||
# interface_info = gr.external.get_huggingface_interface(
|
||||
# "distilbert-base-uncased-finetuned-sst-2-english",
|
||||
# api_key=None,
|
||||
# alias=model_type,
|
||||
# )
|
||||
# self.assertEqual(interface_info["fn"].__name__, model_type)
|
||||
# self.assertIsInstance(interface_info["inputs"], gr.components.Textbox)
|
||||
# self.assertIsInstance(interface_info["outputs"], gr.components.Label)
|
||||
|
||||
def test_fill_mask(self):
|
||||
model_type = "fill-mask"
|
||||
interface_info = gr.external.get_huggingface_interface(
|
||||
"bert-base-uncased", api_key=None, alias=model_type
|
||||
)
|
||||
self.assertEqual(interface_info["fn"].__name__, model_type)
|
||||
self.assertIsInstance(interface_info["inputs"], gr.components.Textbox)
|
||||
self.assertIsInstance(interface_info["outputs"], gr.components.Label)
|
||||
# def test_fill_mask(self):
|
||||
# model_type = "fill-mask"
|
||||
# interface_info = gr.external.get_huggingface_interface(
|
||||
# "bert-base-uncased", api_key=None, alias=model_type
|
||||
# )
|
||||
# self.assertEqual(interface_info["fn"].__name__, model_type)
|
||||
# self.assertIsInstance(interface_info["inputs"], gr.components.Textbox)
|
||||
# self.assertIsInstance(interface_info["outputs"], gr.components.Label)
|
||||
|
||||
def test_zero_shot_classification(self):
|
||||
model_type = "zero-shot-classification"
|
||||
interface_info = gr.external.get_huggingface_interface(
|
||||
"facebook/bart-large-mnli", api_key=None, alias=model_type
|
||||
)
|
||||
self.assertEqual(interface_info["fn"].__name__, model_type)
|
||||
self.assertIsInstance(interface_info["inputs"][0], gr.components.Textbox)
|
||||
self.assertIsInstance(interface_info["inputs"][1], gr.components.Textbox)
|
||||
self.assertIsInstance(interface_info["inputs"][2], gr.components.Checkbox)
|
||||
self.assertIsInstance(interface_info["outputs"], gr.components.Label)
|
||||
# def test_zero_shot_classification(self):
|
||||
# model_type = "zero-shot-classification"
|
||||
# interface_info = gr.external.get_huggingface_interface(
|
||||
# "facebook/bart-large-mnli", api_key=None, alias=model_type
|
||||
# )
|
||||
# self.assertEqual(interface_info["fn"].__name__, model_type)
|
||||
# self.assertIsInstance(interface_info["inputs"][0], gr.components.Textbox)
|
||||
# self.assertIsInstance(interface_info["inputs"][1], gr.components.Textbox)
|
||||
# self.assertIsInstance(interface_info["inputs"][2], gr.components.Checkbox)
|
||||
# self.assertIsInstance(interface_info["outputs"], gr.components.Label)
|
||||
|
||||
def test_automatic_speech_recognition(self):
|
||||
model_type = "automatic-speech-recognition"
|
||||
interface_info = gr.external.get_huggingface_interface(
|
||||
"facebook/wav2vec2-base-960h", api_key=None, alias=model_type
|
||||
)
|
||||
self.assertEqual(interface_info["fn"].__name__, model_type)
|
||||
self.assertIsInstance(interface_info["inputs"], gr.components.Audio)
|
||||
self.assertIsInstance(interface_info["outputs"], gr.components.Textbox)
|
||||
# def test_automatic_speech_recognition(self):
|
||||
# model_type = "automatic-speech-recognition"
|
||||
# interface_info = gr.external.get_huggingface_interface(
|
||||
# "facebook/wav2vec2-base-960h", api_key=None, alias=model_type
|
||||
# )
|
||||
# self.assertEqual(interface_info["fn"].__name__, model_type)
|
||||
# self.assertIsInstance(interface_info["inputs"], gr.components.Audio)
|
||||
# self.assertIsInstance(interface_info["outputs"], gr.components.Textbox)
|
||||
|
||||
def test_image_classification(self):
|
||||
model_type = "image-classification"
|
||||
interface_info = gr.external.get_huggingface_interface(
|
||||
"google/vit-base-patch16-224", api_key=None, alias=model_type
|
||||
)
|
||||
self.assertEqual(interface_info["fn"].__name__, model_type)
|
||||
self.assertIsInstance(interface_info["inputs"], gr.components.Image)
|
||||
self.assertIsInstance(interface_info["outputs"], gr.components.Label)
|
||||
# def test_image_classification(self):
|
||||
# model_type = "image-classification"
|
||||
# interface_info = gr.external.get_huggingface_interface(
|
||||
# "google/vit-base-patch16-224", api_key=None, alias=model_type
|
||||
# )
|
||||
# self.assertEqual(interface_info["fn"].__name__, model_type)
|
||||
# self.assertIsInstance(interface_info["inputs"], gr.components.Image)
|
||||
# self.assertIsInstance(interface_info["outputs"], gr.components.Label)
|
||||
|
||||
def test_feature_extraction(self):
|
||||
model_type = "feature-extraction"
|
||||
interface_info = gr.external.get_huggingface_interface(
|
||||
"sentence-transformers/distilbert-base-nli-mean-tokens",
|
||||
api_key=None,
|
||||
alias=model_type,
|
||||
)
|
||||
self.assertEqual(interface_info["fn"].__name__, model_type)
|
||||
self.assertIsInstance(interface_info["inputs"], gr.components.Textbox)
|
||||
self.assertIsInstance(interface_info["outputs"], gr.components.Dataframe)
|
||||
# def test_feature_extraction(self):
|
||||
# model_type = "feature-extraction"
|
||||
# interface_info = gr.external.get_huggingface_interface(
|
||||
# "sentence-transformers/distilbert-base-nli-mean-tokens",
|
||||
# api_key=None,
|
||||
# alias=model_type,
|
||||
# )
|
||||
# self.assertEqual(interface_info["fn"].__name__, model_type)
|
||||
# self.assertIsInstance(interface_info["inputs"], gr.components.Textbox)
|
||||
# self.assertIsInstance(interface_info["outputs"], gr.components.Dataframe)
|
||||
|
||||
def test_sentence_similarity(self):
|
||||
model_type = "text-to-speech"
|
||||
interface_info = gr.external.get_huggingface_interface(
|
||||
"julien-c/ljspeech_tts_train_tacotron2_raw_phn_tacotron_g2p_en_no_space_train",
|
||||
api_key=None,
|
||||
alias=model_type,
|
||||
)
|
||||
self.assertEqual(interface_info["fn"].__name__, model_type)
|
||||
self.assertIsInstance(interface_info["inputs"], gr.components.Textbox)
|
||||
self.assertIsInstance(interface_info["outputs"], gr.components.Audio)
|
||||
# def test_sentence_similarity(self):
|
||||
# model_type = "text-to-speech"
|
||||
# interface_info = gr.external.get_huggingface_interface(
|
||||
# "julien-c/ljspeech_tts_train_tacotron2_raw_phn_tacotron_g2p_en_no_space_train",
|
||||
# api_key=None,
|
||||
# alias=model_type,
|
||||
# )
|
||||
# self.assertEqual(interface_info["fn"].__name__, model_type)
|
||||
# self.assertIsInstance(interface_info["inputs"], gr.components.Textbox)
|
||||
# self.assertIsInstance(interface_info["outputs"], gr.components.Audio)
|
||||
|
||||
def test_text_to_speech(self):
|
||||
model_type = "text-to-speech"
|
||||
interface_info = gr.external.get_huggingface_interface(
|
||||
"julien-c/ljspeech_tts_train_tacotron2_raw_phn_tacotron_g2p_en_no_space_train",
|
||||
api_key=None,
|
||||
alias=model_type,
|
||||
)
|
||||
self.assertEqual(interface_info["fn"].__name__, model_type)
|
||||
self.assertIsInstance(interface_info["inputs"], gr.components.Textbox)
|
||||
self.assertIsInstance(interface_info["outputs"], gr.components.Audio)
|
||||
# def test_text_to_speech(self):
|
||||
# model_type = "text-to-speech"
|
||||
# interface_info = gr.external.get_huggingface_interface(
|
||||
# "julien-c/ljspeech_tts_train_tacotron2_raw_phn_tacotron_g2p_en_no_space_train",
|
||||
# api_key=None,
|
||||
# alias=model_type,
|
||||
# )
|
||||
# self.assertEqual(interface_info["fn"].__name__, model_type)
|
||||
# self.assertIsInstance(interface_info["inputs"], gr.components.Textbox)
|
||||
# self.assertIsInstance(interface_info["outputs"], gr.components.Audio)
|
||||
|
||||
def test_text_to_image(self):
|
||||
model_type = "text-to-image"
|
||||
interface_info = gr.external.get_huggingface_interface(
|
||||
"osanseviero/BigGAN-deep-128", api_key=None, alias=model_type
|
||||
)
|
||||
self.assertEqual(interface_info["fn"].__name__, model_type)
|
||||
self.assertIsInstance(interface_info["inputs"], gr.components.Textbox)
|
||||
self.assertIsInstance(interface_info["outputs"], gr.components.Image)
|
||||
# def test_text_to_image(self):
|
||||
# model_type = "text-to-image"
|
||||
# interface_info = gr.external.get_huggingface_interface(
|
||||
# "osanseviero/BigGAN-deep-128", api_key=None, alias=model_type
|
||||
# )
|
||||
# self.assertEqual(interface_info["fn"].__name__, model_type)
|
||||
# self.assertIsInstance(interface_info["inputs"], gr.components.Textbox)
|
||||
# self.assertIsInstance(interface_info["outputs"], gr.components.Image)
|
||||
|
||||
def test_english_to_spanish(self):
|
||||
interface_info = gr.external.get_spaces_interface(
|
||||
"abidlabs/english_to_spanish", api_key=None, alias=None
|
||||
)
|
||||
self.assertIsInstance(interface_info["inputs"][0], gr.components.Textbox)
|
||||
self.assertIsInstance(interface_info["outputs"][0], gr.components.Textbox)
|
||||
# def test_english_to_spanish(self):
|
||||
# interface_info = gr.external.get_spaces_interface(
|
||||
# "abidlabs/english_to_spanish", api_key=None, alias=None
|
||||
# )
|
||||
# self.assertIsInstance(interface_info["inputs"][0], gr.components.Textbox)
|
||||
# self.assertIsInstance(interface_info["outputs"][0], gr.components.Textbox)
|
||||
|
||||
|
||||
class TestLoadInterface(unittest.TestCase):
|
||||
def test_english_to_spanish(self):
|
||||
interface_info = gr.external.load_interface(
|
||||
"spaces/abidlabs/english_to_spanish"
|
||||
)
|
||||
self.assertIsInstance(interface_info["inputs"][0], gr.components.Textbox)
|
||||
self.assertIsInstance(interface_info["outputs"][0], gr.components.Textbox)
|
||||
# class TestLoadInterface(unittest.TestCase):
|
||||
# def test_english_to_spanish(self):
|
||||
# interface_info = gr.external.load_interface(
|
||||
# "spaces/abidlabs/english_to_spanish"
|
||||
# )
|
||||
# self.assertIsInstance(interface_info["inputs"][0], gr.components.Textbox)
|
||||
# self.assertIsInstance(interface_info["outputs"][0], gr.components.Textbox)
|
||||
|
||||
def test_sentiment_model(self):
|
||||
interface_info = gr.external.load_interface(
|
||||
"models/distilbert-base-uncased-finetuned-sst-2-english",
|
||||
alias="sentiment_classifier",
|
||||
)
|
||||
io = gr.Interface(**interface_info)
|
||||
io.api_mode = True
|
||||
output = io("I am happy, I love you.")
|
||||
self.assertGreater(output["POSITIVE"], 0.5)
|
||||
# def test_sentiment_model(self):
|
||||
# interface_info = gr.external.load_interface(
|
||||
# "models/distilbert-base-uncased-finetuned-sst-2-english",
|
||||
# alias="sentiment_classifier",
|
||||
# )
|
||||
# io = gr.Interface(**interface_info)
|
||||
# io.api_mode = True
|
||||
# output = io("I am happy, I love you.")
|
||||
# self.assertGreater(output["POSITIVE"], 0.5)
|
||||
|
||||
def test_image_classification_model(self):
|
||||
interface_info = gr.external.load_interface(
|
||||
"models/google/vit-base-patch16-224"
|
||||
)
|
||||
io = gr.Interface(**interface_info)
|
||||
io.api_mode = True
|
||||
output = io("test/test_data/lion.jpg")
|
||||
self.assertGreater(output["lion"], 0.5)
|
||||
# def test_image_classification_model(self):
|
||||
# interface_info = gr.external.load_interface(
|
||||
# "models/google/vit-base-patch16-224"
|
||||
# )
|
||||
# io = gr.Interface(**interface_info)
|
||||
# io.api_mode = True
|
||||
# output = io("test/test_data/lion.jpg")
|
||||
# self.assertGreater(output["lion"], 0.5)
|
||||
|
||||
def test_translation_model(self):
|
||||
interface_info = gr.external.load_interface("models/t5-base")
|
||||
io = gr.Interface(**interface_info)
|
||||
io.api_mode = True
|
||||
output = io("My name is Sarah and I live in London")
|
||||
self.assertEquals(output, "Mein Name ist Sarah und ich lebe in London")
|
||||
# def test_translation_model(self):
|
||||
# interface_info = gr.external.load_interface("models/t5-base")
|
||||
# io = gr.Interface(**interface_info)
|
||||
# io.api_mode = True
|
||||
# output = io("My name is Sarah and I live in London")
|
||||
# self.assertEqual(output, "Mein Name ist Sarah und ich lebe in London")
|
||||
|
||||
def test_numerical_to_label_space(self):
|
||||
interface_info = gr.external.load_interface("spaces/abidlabs/titanic-survival")
|
||||
io = gr.Interface(**interface_info)
|
||||
io.api_mode = True
|
||||
output = io("male", 77, 10)
|
||||
self.assertLess(output["Survives"], 0.5)
|
||||
# def test_numerical_to_label_space(self):
|
||||
# interface_info = gr.external.load_interface("spaces/abidlabs/titanic-survival")
|
||||
# io = gr.Interface(**interface_info)
|
||||
# io.api_mode = True
|
||||
# output = io("male", 77, 10)
|
||||
# self.assertLess(output["Survives"], 0.5)
|
||||
|
||||
def test_speech_recognition_model(self):
|
||||
interface_info = gr.external.load_interface(
|
||||
"models/jonatasgrosman/wav2vec2-large-xlsr-53-english"
|
||||
)
|
||||
io = gr.Interface(**interface_info)
|
||||
io.api_mode = True
|
||||
output = io("test/test_data/test_audio.wav")
|
||||
self.assertIsNotNone(output)
|
||||
# def test_speech_recognition_model(self):
|
||||
# interface_info = gr.external.load_interface(
|
||||
# "models/jonatasgrosman/wav2vec2-large-xlsr-53-english"
|
||||
# )
|
||||
# io = gr.Interface(**interface_info)
|
||||
# io.api_mode = True
|
||||
# output = io("test/test_data/test_audio.wav")
|
||||
# self.assertIsNotNone(output)
|
||||
|
||||
def test_text_to_image_model(self):
|
||||
interface_info = gr.external.load_interface(
|
||||
"models/osanseviero/BigGAN-deep-128"
|
||||
)
|
||||
io = gr.Interface(**interface_info)
|
||||
io.api_mode = True
|
||||
filename = io("chest")
|
||||
self.assertTrue(filename.endswith(".jpg") or filename.endswith(".jpeg"))
|
||||
# def test_text_to_image_model(self):
|
||||
# interface_info = gr.external.load_interface(
|
||||
# "models/osanseviero/BigGAN-deep-128"
|
||||
# )
|
||||
# io = gr.Interface(**interface_info)
|
||||
# io.api_mode = True
|
||||
# filename = io("chest")
|
||||
# self.assertTrue(filename.endswith(".jpg") or filename.endswith(".jpeg"))
|
||||
|
||||
def test_image_to_image_space(self):
|
||||
def assertIsFile(path):
|
||||
if not pathlib.Path(path).resolve().is_file():
|
||||
raise AssertionError("File does not exist: %s" % str(path))
|
||||
# def test_image_to_image_space(self):
|
||||
# def assertIsFile(path):
|
||||
# if not pathlib.Path(path).resolve().is_file():
|
||||
# raise AssertionError("File does not exist: %s" % str(path))
|
||||
|
||||
interface_info = gr.external.load_interface("spaces/abidlabs/image-identity")
|
||||
io = gr.Interface(**interface_info)
|
||||
io.api_mode = True
|
||||
output = io("test/test_data/lion.jpg")
|
||||
assertIsFile(output)
|
||||
# interface_info = gr.external.load_interface("spaces/abidlabs/image-identity")
|
||||
# io = gr.Interface(**interface_info)
|
||||
# io.api_mode = True
|
||||
# output = io("test/test_data/lion.jpg")
|
||||
# assertIsFile(output)
|
||||
|
||||
|
||||
class TestLoadFromPipeline(unittest.TestCase):
|
||||
def test_text_to_text_model_from_pipeline(self):
|
||||
pipe = transformers.pipeline(model="sshleifer/bart-tiny-random")
|
||||
output = pipe("My name is Sylvain and I work at Hugging Face in Brooklyn")
|
||||
self.assertIsNotNone(output)
|
||||
# class TestLoadFromPipeline(unittest.TestCase):
|
||||
# def test_text_to_text_model_from_pipeline(self):
|
||||
# pipe = transformers.pipeline(model="sshleifer/bart-tiny-random")
|
||||
# output = pipe("My name is Sylvain and I work at Hugging Face in Brooklyn")
|
||||
# self.assertIsNotNone(output)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
# if __name__ == "__main__":
|
||||
# unittest.main()
|
||||
|
||||
@ -8,63 +8,62 @@ import huggingface_hub
|
||||
import gradio as gr
|
||||
from gradio import flagging
|
||||
|
||||
|
||||
class TestDefaultFlagging(unittest.TestCase):
|
||||
def test_default_flagging_callback(self):
|
||||
with tempfile.TemporaryDirectory() as tmpdirname:
|
||||
io = gr.Interface(lambda x: x, "text", "text", flagging_dir=tmpdirname)
|
||||
io.launch(prevent_thread_lock=True)
|
||||
row_count = io.flagging_callback.flag(io, ["test"], ["test"])
|
||||
self.assertEqual(row_count, 1) # 2 rows written including header
|
||||
row_count = io.flagging_callback.flag(io, ["test"], ["test"])
|
||||
self.assertEqual(row_count, 2) # 3 rows written including header
|
||||
io.close()
|
||||
# class TestDefaultFlagging(unittest.TestCase):
|
||||
# def test_default_flagging_callback(self):
|
||||
# with tempfile.TemporaryDirectory() as tmpdirname:
|
||||
# io = gr.Interface(lambda x: x, "text", "text", flagging_dir=tmpdirname)
|
||||
# io.launch(prevent_thread_lock=True)
|
||||
# row_count = io.flagging_callback.flag(io, ["test"], ["test"])
|
||||
# self.assertEqual(row_count, 1) # 2 rows written including header
|
||||
# row_count = io.flagging_callback.flag(io, ["test"], ["test"])
|
||||
# self.assertEqual(row_count, 2) # 3 rows written including header
|
||||
# io.close()
|
||||
|
||||
|
||||
class TestSimpleFlagging(unittest.TestCase):
|
||||
def test_simple_csv_flagging_callback(self):
|
||||
with tempfile.TemporaryDirectory() as tmpdirname:
|
||||
io = gr.Interface(
|
||||
lambda x: x,
|
||||
"text",
|
||||
"text",
|
||||
flagging_dir=tmpdirname,
|
||||
flagging_callback=flagging.SimpleCSVLogger(),
|
||||
)
|
||||
io.launch(prevent_thread_lock=True)
|
||||
row_count = io.flagging_callback.flag(io, ["test"], ["test"])
|
||||
self.assertEqual(row_count, 0) # no header in SimpleCSVLogger
|
||||
row_count = io.flagging_callback.flag(io, ["test"], ["test"])
|
||||
self.assertEqual(row_count, 1) # no header in SimpleCSVLogger
|
||||
io.close()
|
||||
# class TestSimpleFlagging(unittest.TestCase):
|
||||
# def test_simple_csv_flagging_callback(self):
|
||||
# with tempfile.TemporaryDirectory() as tmpdirname:
|
||||
# io = gr.Interface(
|
||||
# lambda x: x,
|
||||
# "text",
|
||||
# "text",
|
||||
# flagging_dir=tmpdirname,
|
||||
# flagging_callback=flagging.SimpleCSVLogger(),
|
||||
# )
|
||||
# io.launch(prevent_thread_lock=True)
|
||||
# row_count = io.flagging_callback.flag(io, ["test"], ["test"])
|
||||
# self.assertEqual(row_count, 0) # no header in SimpleCSVLogger
|
||||
# row_count = io.flagging_callback.flag(io, ["test"], ["test"])
|
||||
# self.assertEqual(row_count, 1) # no header in SimpleCSVLogger
|
||||
# io.close()
|
||||
|
||||
|
||||
class TestHuggingFaceDatasetSaver(unittest.TestCase):
|
||||
def test_saver_setup(self):
|
||||
huggingface_hub.create_repo = MagicMock()
|
||||
huggingface_hub.Repository = MagicMock()
|
||||
flagger = flagging.HuggingFaceDatasetSaver("test", "test")
|
||||
with tempfile.TemporaryDirectory() as tmpdirname:
|
||||
flagger.setup(tmpdirname)
|
||||
huggingface_hub.create_repo.assert_called_once()
|
||||
# class TestHuggingFaceDatasetSaver(unittest.TestCase):
|
||||
# def test_saver_setup(self):
|
||||
# huggingface_hub.create_repo = MagicMock()
|
||||
# huggingface_hub.Repository = MagicMock()
|
||||
# flagger = flagging.HuggingFaceDatasetSaver("test", "test")
|
||||
# with tempfile.TemporaryDirectory() as tmpdirname:
|
||||
# flagger.setup(tmpdirname)
|
||||
# huggingface_hub.create_repo.assert_called_once()
|
||||
|
||||
def test_saver_flag(self):
|
||||
huggingface_hub.create_repo = MagicMock()
|
||||
huggingface_hub.Repository = MagicMock()
|
||||
with tempfile.TemporaryDirectory() as tmpdirname:
|
||||
io = gr.Interface(
|
||||
lambda x: x,
|
||||
"text",
|
||||
"text",
|
||||
flagging_dir=tmpdirname,
|
||||
flagging_callback=flagging.HuggingFaceDatasetSaver("test", "test"),
|
||||
)
|
||||
os.mkdir(os.path.join(tmpdirname, "test"))
|
||||
io.launch(prevent_thread_lock=True)
|
||||
row_count = io.flagging_callback.flag(io, ["test"], ["test"])
|
||||
self.assertEqual(row_count, 1) # 2 rows written including header
|
||||
row_count = io.flagging_callback.flag(io, ["test"], ["test"])
|
||||
self.assertEqual(row_count, 2) # 3 rows written including header
|
||||
# def test_saver_flag(self):
|
||||
# huggingface_hub.create_repo = MagicMock()
|
||||
# huggingface_hub.Repository = MagicMock()
|
||||
# with tempfile.TemporaryDirectory() as tmpdirname:
|
||||
# io = gr.Interface(
|
||||
# lambda x: x,
|
||||
# "text",
|
||||
# "text",
|
||||
# flagging_dir=tmpdirname,
|
||||
# flagging_callback=flagging.HuggingFaceDatasetSaver("test", "test"),
|
||||
# )
|
||||
# os.mkdir(os.path.join(tmpdirname, "test"))
|
||||
# io.launch(prevent_thread_lock=True)
|
||||
# row_count = io.flagging_callback.flag(io, ["test"], ["test"])
|
||||
# self.assertEqual(row_count, 1) # 2 rows written including header
|
||||
# row_count = io.flagging_callback.flag(io, ["test"], ["test"])
|
||||
# self.assertEqual(row_count, 2) # 3 rows written including header
|
||||
|
||||
|
||||
class TestDisableFlagging(unittest.TestCase):
|
||||
|
||||
@ -130,7 +130,7 @@ class TestNumber(unittest.TestCase):
|
||||
)
|
||||
self.assertEqual(
|
||||
numeric_input.get_template_context(),
|
||||
{"default": None, "name": "number", "label": None},
|
||||
{"default": None, "name": "number", "label": None, "css": {}},
|
||||
)
|
||||
|
||||
def test_in_interface(self):
|
||||
@ -194,6 +194,7 @@ class TestSlider(unittest.TestCase):
|
||||
"default": 15,
|
||||
"name": "slider",
|
||||
"label": "Slide Your Input",
|
||||
"css": {},
|
||||
},
|
||||
)
|
||||
|
||||
@ -255,6 +256,7 @@ class TestCheckbox(unittest.TestCase):
|
||||
"default": True,
|
||||
"name": "checkbox",
|
||||
"label": "Check Your Input",
|
||||
"css": {},
|
||||
},
|
||||
)
|
||||
|
||||
@ -296,6 +298,7 @@ class TestCheckboxGroup(unittest.TestCase):
|
||||
"default": ["a", "c"],
|
||||
"name": "checkboxgroup",
|
||||
"label": "Check Your Inputs",
|
||||
"css": {},
|
||||
},
|
||||
)
|
||||
with self.assertRaises(ValueError):
|
||||
@ -332,6 +335,7 @@ class TestRadio(unittest.TestCase):
|
||||
"default": "a",
|
||||
"name": "radio",
|
||||
"label": "Pick Your One Input",
|
||||
"css": {},
|
||||
},
|
||||
)
|
||||
with self.assertRaises(ValueError):
|
||||
@ -376,6 +380,7 @@ class TestDropdown(unittest.TestCase):
|
||||
"default": "a",
|
||||
"name": "dropdown",
|
||||
"label": "Drop Your Input",
|
||||
"css": {},
|
||||
},
|
||||
)
|
||||
with self.assertRaises(ValueError):
|
||||
@ -428,6 +433,7 @@ class TestImage(unittest.TestCase):
|
||||
"tool": "editor",
|
||||
"name": "image",
|
||||
"label": "Upload Your Image",
|
||||
"css": {},
|
||||
},
|
||||
)
|
||||
self.assertIsNone(image_input.preprocess(None))
|
||||
@ -524,6 +530,7 @@ class TestAudio(unittest.TestCase):
|
||||
"source": "upload",
|
||||
"name": "audio",
|
||||
"label": "Upload Your Audio",
|
||||
"css": {},
|
||||
},
|
||||
)
|
||||
self.assertIsNone(audio_input.preprocess(None))
|
||||
@ -582,6 +589,7 @@ class TestFile(unittest.TestCase):
|
||||
"file_count": "single",
|
||||
"name": "file",
|
||||
"label": "Upload Your File",
|
||||
"css": {},
|
||||
},
|
||||
)
|
||||
self.assertIsNone(file_input.preprocess(None))
|
||||
@ -634,6 +642,7 @@ class TestDataframe(unittest.TestCase):
|
||||
"max_rows": 20,
|
||||
"max_cols": None,
|
||||
"overflow_row_behaviour": "paginate",
|
||||
"css": {},
|
||||
},
|
||||
)
|
||||
dataframe_input = gr.inputs.Dataframe()
|
||||
@ -679,6 +688,7 @@ class TestVideo(unittest.TestCase):
|
||||
"source": "upload",
|
||||
"name": "video",
|
||||
"label": "Upload Your Video",
|
||||
"css": {},
|
||||
},
|
||||
)
|
||||
self.assertIsNone(video_input.preprocess(None))
|
||||
@ -724,6 +734,7 @@ class TestTimeseries(unittest.TestCase):
|
||||
"y": ["retail"],
|
||||
"name": "timeseries",
|
||||
"label": "Upload Your Timeseries",
|
||||
"css": {},
|
||||
},
|
||||
)
|
||||
self.assertIsNone(timeseries_input.preprocess(None))
|
||||
|
||||
@ -40,26 +40,26 @@ class TestInterface(unittest.TestCase):
|
||||
close_all()
|
||||
interface.close.assert_called()
|
||||
|
||||
def test_examples_invalid_input(self):
|
||||
with self.assertRaises(ValueError):
|
||||
Interface(lambda x: x, examples=1234)
|
||||
# def test_examples_invalid_input(self):
|
||||
# with self.assertRaises(ValueError):
|
||||
# Interface(lambda x: x, examples=1234)
|
||||
|
||||
def test_examples_valid_path(self):
|
||||
path = os.path.join(os.path.dirname(__file__), "test_data/flagged_with_log")
|
||||
interface = Interface(lambda x: 3 * x, "number", "number", examples=path)
|
||||
self.assertEqual(len(interface.get_config_file()["examples"]), 2)
|
||||
# def test_examples_valid_path(self):
|
||||
# path = os.path.join(os.path.dirname(__file__), "test_data/flagged_with_log")
|
||||
# interface = Interface(lambda x: 3 * x, "number", "number", examples=path)
|
||||
# self.assertEqual(len(interface.get_config_file()["examples"]), 2)
|
||||
|
||||
path = os.path.join(os.path.dirname(__file__), "test_data/flagged_no_log")
|
||||
interface = Interface(lambda x: 3 * x, "number", "number", examples=path)
|
||||
self.assertEqual(len(interface.get_config_file()["examples"]), 3)
|
||||
# path = os.path.join(os.path.dirname(__file__), "test_data/flagged_no_log")
|
||||
# interface = Interface(lambda x: 3 * x, "number", "number", examples=path)
|
||||
# self.assertEqual(len(interface.get_config_file()["examples"]), 3)
|
||||
|
||||
def test_examples_not_valid_path(self):
|
||||
with self.assertRaises(FileNotFoundError):
|
||||
interface = Interface(
|
||||
lambda x: x, "textbox", "label", examples="invalid-path"
|
||||
)
|
||||
interface.launch(prevent_thread_lock=True)
|
||||
interface.close()
|
||||
# def test_examples_not_valid_path(self):
|
||||
# with self.assertRaises(FileNotFoundError):
|
||||
# interface = Interface(
|
||||
# lambda x: x, "textbox", "label", examples="invalid-path"
|
||||
# )
|
||||
# interface.launch(prevent_thread_lock=True)
|
||||
# interface.close()
|
||||
|
||||
def test_test_launch(self):
|
||||
with captured_output() as (out, err):
|
||||
@ -107,14 +107,6 @@ class TestInterface(unittest.TestCase):
|
||||
self.assertTrue(prediction_fn.__name__ in repr[0])
|
||||
self.assertEqual(len(repr[0]), len(repr[1]))
|
||||
|
||||
def test_interface_load(self):
|
||||
io = Interface.load(
|
||||
"models/distilbert-base-uncased-finetuned-sst-2-english",
|
||||
alias="sentiment_classifier",
|
||||
)
|
||||
output = io("I am happy, I love you.")
|
||||
self.assertGreater(output["POSITIVE"], 0.5)
|
||||
|
||||
def test_interface_none_interp(self):
|
||||
interface = Interface(lambda x: x, "textbox", "label", interpretation=[None])
|
||||
scores, alternative_outputs = interface.interpret(["quickest brown fox"])
|
||||
|
||||
@ -19,12 +19,12 @@ class TestSeries(unittest.TestCase):
|
||||
series = mix.Series(io1, io2)
|
||||
self.assertEqual(series.process(["Hello"])[0], ["Hello World!"])
|
||||
|
||||
def test_with_external(self):
|
||||
io1 = gr.Interface.load("spaces/abidlabs/image-identity")
|
||||
io2 = gr.Interface.load("spaces/abidlabs/image-classifier")
|
||||
series = mix.Series(io1, io2)
|
||||
output = series("test/test_data/lion.jpg")
|
||||
self.assertGreater(output["lion"], 0.5)
|
||||
# def test_with_external(self):
|
||||
# io1 = gr.Interface.load("spaces/abidlabs/image-identity")
|
||||
# io2 = gr.Interface.load("spaces/abidlabs/image-classifier")
|
||||
# series = mix.Series(io1, io2)
|
||||
# output = series("test/test_data/lion.jpg")
|
||||
# self.assertGreater(output["lion"], 0.5)
|
||||
|
||||
|
||||
class TestParallel(unittest.TestCase):
|
||||
@ -36,13 +36,13 @@ class TestParallel(unittest.TestCase):
|
||||
parallel.process(["Hello"])[0], ["Hello World 1!", "Hello World 2!"]
|
||||
)
|
||||
|
||||
def test_with_external(self):
|
||||
io1 = gr.Interface.load("spaces/abidlabs/english_to_spanish")
|
||||
io2 = gr.Interface.load("spaces/abidlabs/english2german")
|
||||
parallel = mix.Parallel(io1, io2)
|
||||
hello_es, hello_de = parallel("Hello")
|
||||
self.assertIn("hola", hello_es.lower())
|
||||
self.assertIn("hallo", hello_de.lower())
|
||||
# def test_with_external(self):
|
||||
# io1 = gr.Interface.load("spaces/abidlabs/english_to_spanish")
|
||||
# io2 = gr.Interface.load("spaces/abidlabs/english2german")
|
||||
# parallel = mix.Parallel(io1, io2)
|
||||
# hello_es, hello_de = parallel("Hello")
|
||||
# self.assertIn("hola", hello_es.lower())
|
||||
# self.assertIn("hallo", hello_de.lower())
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
@ -1,3 +1,4 @@
|
||||
import json
|
||||
import os
|
||||
import tempfile
|
||||
import unittest
|
||||
@ -11,26 +12,12 @@ import gradio as gr
|
||||
os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"
|
||||
|
||||
|
||||
class OutputComponent(unittest.TestCase):
|
||||
def test_as_component(self):
|
||||
output = gr.outputs.OutputComponent(label="Test Input")
|
||||
self.assertEqual(output.postprocess("Hello World!"), "Hello World!")
|
||||
self.assertEqual(output.deserialize(1), 1)
|
||||
|
||||
|
||||
class TestTextbox(unittest.TestCase):
|
||||
def test_as_component(self):
|
||||
with self.assertRaises(ValueError):
|
||||
wrong_type = gr.outputs.Textbox(type="unknown")
|
||||
wrong_type.postprocess(0)
|
||||
|
||||
def test_in_interface(self):
|
||||
iface = gr.Interface(lambda x: x[-1], "textbox", gr.outputs.Textbox())
|
||||
self.assertEqual(iface.process(["Hello"])[0], ["o"])
|
||||
iface = gr.Interface(
|
||||
lambda x: x / 2, "number", gr.outputs.Textbox(type="number")
|
||||
)
|
||||
self.assertEqual(iface.process([10])[0], [5])
|
||||
iface = gr.Interface(lambda x: x / 2, "number", gr.outputs.Textbox())
|
||||
self.assertEqual(iface.process([10])[0], ["5.0"])
|
||||
|
||||
|
||||
class TestLabel(unittest.TestCase):
|
||||
@ -86,9 +73,6 @@ class TestLabel(unittest.TestCase):
|
||||
],
|
||||
},
|
||||
)
|
||||
with self.assertRaises(ValueError):
|
||||
label_output = gr.outputs.Label(type="unknown")
|
||||
label_output.deserialize([1, 2, 3])
|
||||
|
||||
def test_in_interface(self):
|
||||
x_img = gr.test_data.BASE64_IMAGE
|
||||
@ -189,36 +173,6 @@ class TestVideo(unittest.TestCase):
|
||||
self.assertEqual("video_output/1.mp4", to_save)
|
||||
|
||||
|
||||
class TestKeyValues(unittest.TestCase):
|
||||
def test_as_component(self):
|
||||
kv_output = gr.outputs.KeyValues()
|
||||
kv_dict = {"a": 1, "b": 2}
|
||||
kv_list = [("a", 1), ("b", 2)]
|
||||
self.assertEqual(kv_output.postprocess(kv_dict), kv_list)
|
||||
self.assertEqual(kv_output.postprocess(kv_list), kv_list)
|
||||
with self.assertRaises(ValueError):
|
||||
kv_output.postprocess(0)
|
||||
with tempfile.TemporaryDirectory() as tmpdirname:
|
||||
to_save = kv_output.save_flagged(tmpdirname, "kv_output", kv_list, None)
|
||||
self.assertEqual(to_save, '[["a", 1], ["b", 2]]')
|
||||
self.assertEqual(
|
||||
kv_output.restore_flagged(tmpdirname, to_save, None),
|
||||
[["a", 1], ["b", 2]],
|
||||
)
|
||||
|
||||
def test_in_interface(self):
|
||||
def letter_distribution(word):
|
||||
dist = {}
|
||||
for letter in word:
|
||||
dist[letter] = dist.get(letter, 0) + 1
|
||||
return dist
|
||||
|
||||
iface = gr.Interface(letter_distribution, "text", "key_values")
|
||||
self.assertListEqual(
|
||||
iface.process(["alpaca"])[0][0], [("a", 3), ("l", 1), ("p", 1), ("c", 1)]
|
||||
)
|
||||
|
||||
|
||||
class TestHighlightedText(unittest.TestCase):
|
||||
def test_as_component(self):
|
||||
ht_output = gr.outputs.HighlightedText(color_map={"pos": "green", "neg": "red"})
|
||||
@ -229,6 +183,7 @@ class TestHighlightedText(unittest.TestCase):
|
||||
"name": "highlightedtext",
|
||||
"label": None,
|
||||
"show_legend": False,
|
||||
"css": {},
|
||||
},
|
||||
)
|
||||
ht = {"pos": "Hello ", "neg": "World"}
|
||||
@ -275,21 +230,19 @@ class TestAudio(unittest.TestCase):
|
||||
)
|
||||
)
|
||||
self.assertEqual(
|
||||
audio_output.get_template_context(), {"name": "audio", "label": None}
|
||||
audio_output.get_template_context(),
|
||||
{"name": "audio", "label": None, "source": "upload", "css": {}},
|
||||
)
|
||||
with self.assertRaises(ValueError):
|
||||
wrong_type = gr.outputs.Audio(type="unknown")
|
||||
wrong_type.postprocess(y_audio.name)
|
||||
self.assertTrue(
|
||||
audio_output.deserialize(gr.test_data.BASE64_AUDIO["data"]).endswith(".wav")
|
||||
)
|
||||
with tempfile.TemporaryDirectory() as tmpdirname:
|
||||
to_save = audio_output.save_flagged(
|
||||
tmpdirname, "audio_output", gr.test_data.BASE64_AUDIO["data"], None
|
||||
tmpdirname, "audio_output", gr.test_data.BASE64_AUDIO, None
|
||||
)
|
||||
self.assertEqual("audio_output/0.wav", to_save)
|
||||
to_save = audio_output.save_flagged(
|
||||
tmpdirname, "audio_output", gr.test_data.BASE64_AUDIO["data"], None
|
||||
tmpdirname, "audio_output", gr.test_data.BASE64_AUDIO, None
|
||||
)
|
||||
self.assertEqual("audio_output/1.wav", to_save)
|
||||
|
||||
@ -367,11 +320,11 @@ class TestFile(unittest.TestCase):
|
||||
file_output = gr.outputs.File()
|
||||
with tempfile.TemporaryDirectory() as tmpdirname:
|
||||
to_save = file_output.save_flagged(
|
||||
tmpdirname, "file_output", gr.test_data.BASE64_FILE, None
|
||||
tmpdirname, "file_output", [gr.test_data.BASE64_FILE], None
|
||||
)
|
||||
self.assertEqual("file_output/0", to_save)
|
||||
to_save = file_output.save_flagged(
|
||||
tmpdirname, "file_output", gr.test_data.BASE64_FILE, None
|
||||
tmpdirname, "file_output", [gr.test_data.BASE64_FILE], None
|
||||
)
|
||||
self.assertEqual("file_output/1", to_save)
|
||||
|
||||
@ -399,6 +352,13 @@ class TestDataframe(unittest.TestCase):
|
||||
"overflow_row_behaviour": "paginate",
|
||||
"name": "dataframe",
|
||||
"label": None,
|
||||
"css": {},
|
||||
"datatype": "str",
|
||||
"row_count": 3,
|
||||
"col_count": 3,
|
||||
"col_width": None,
|
||||
"default": [[None, None, None], [None, None, None], [None, None, None]],
|
||||
"name": "dataframe",
|
||||
},
|
||||
)
|
||||
with self.assertRaises(ValueError):
|
||||
@ -408,10 +368,21 @@ class TestDataframe(unittest.TestCase):
|
||||
to_save = dataframe_output.save_flagged(
|
||||
tmpdirname, "dataframe_output", output, None
|
||||
)
|
||||
self.assertEqual(to_save, "[[2, true], [3, true], [4, false]]")
|
||||
self.assertEqual(
|
||||
to_save,
|
||||
json.dumps(
|
||||
{
|
||||
"headers": ["num", "prime"],
|
||||
"data": [[2, True], [3, True], [4, False]],
|
||||
}
|
||||
),
|
||||
)
|
||||
self.assertEqual(
|
||||
dataframe_output.restore_flagged(tmpdirname, to_save, None),
|
||||
{"data": [[2, True], [3, True], [4, False]]},
|
||||
{
|
||||
"headers": ["num", "prime"],
|
||||
"data": [[2, True], [3, True], [4, False]],
|
||||
},
|
||||
)
|
||||
|
||||
def test_in_interface(self):
|
||||
@ -448,9 +419,19 @@ class TestCarousel(unittest.TestCase):
|
||||
self.assertEqual(
|
||||
carousel_output.get_template_context(),
|
||||
{
|
||||
"components": [{"name": "textbox", "label": None}],
|
||||
"components": [
|
||||
{
|
||||
"name": "textbox",
|
||||
"label": None,
|
||||
"default": "",
|
||||
"lines": 1,
|
||||
"css": {},
|
||||
"placeholder": None,
|
||||
}
|
||||
],
|
||||
"name": "carousel",
|
||||
"label": "Disease",
|
||||
"css": {},
|
||||
},
|
||||
)
|
||||
output = carousel_output.postprocess(["Hello World", "Bye World"])
|
||||
@ -501,7 +482,7 @@ class TestTimeseries(unittest.TestCase):
|
||||
timeseries_output = gr.outputs.Timeseries(label="Disease")
|
||||
self.assertEqual(
|
||||
timeseries_output.get_template_context(),
|
||||
{"x": None, "y": None, "name": "timeseries", "label": "Disease"},
|
||||
{"x": None, "y": None, "name": "timeseries", "label": "Disease", "css": {}},
|
||||
)
|
||||
data = {"Name": ["Tom", "nick", "krish", "jack"], "Age": [20, 21, 19, 18]}
|
||||
df = pd.DataFrame(data)
|
||||
@ -541,14 +522,5 @@ class TestTimeseries(unittest.TestCase):
|
||||
)
|
||||
|
||||
|
||||
class TestNames(unittest.TestCase):
|
||||
def test_no_duplicate_uncased_names(
|
||||
self,
|
||||
): # this ensures that get_input_instance() works correctly when instantiating from components
|
||||
subclasses = gr.outputs.OutputComponent.__subclasses__()
|
||||
unique_subclasses_uncased = set([s.__name__.lower() for s in subclasses])
|
||||
self.assertEqual(len(subclasses), len(unique_subclasses_uncased))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
||||
@ -6,24 +6,24 @@ from gradio import Interface, process_examples
|
||||
os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"
|
||||
|
||||
|
||||
class TestProcessExamples(unittest.TestCase):
|
||||
def test_process_example(self):
|
||||
io = Interface(lambda x: "Hello " + x, "text", "text", examples=[["World"]])
|
||||
prediction, _ = process_examples.process_example(io, 0)
|
||||
self.assertEquals(prediction[0], "Hello World")
|
||||
# class TestProcessExamples(unittest.TestCase):
|
||||
# def test_process_example(self):
|
||||
# io = Interface(lambda x: "Hello " + x, "text", "text", examples=[["World"]])
|
||||
# prediction, _ = process_examples.process_example(io, 0)
|
||||
# self.assertEquals(prediction[0], "Hello World")
|
||||
|
||||
def test_caching(self):
|
||||
io = Interface(
|
||||
lambda x: "Hello " + x,
|
||||
"text",
|
||||
"text",
|
||||
examples=[["World"], ["Dunya"], ["Monde"]],
|
||||
)
|
||||
io.launch(prevent_thread_lock=True)
|
||||
process_examples.cache_interface_examples(io)
|
||||
prediction = process_examples.load_from_cache(io, 1)
|
||||
io.close()
|
||||
self.assertEquals(prediction[0], "Hello Dunya")
|
||||
# def test_caching(self):
|
||||
# io = Interface(
|
||||
# lambda x: "Hello " + x,
|
||||
# "text",
|
||||
# "text",
|
||||
# examples=[["World"], ["Dunya"], ["Monde"]],
|
||||
# )
|
||||
# io.launch(prevent_thread_lock=True)
|
||||
# process_examples.cache_interface_examples(io)
|
||||
# prediction = process_examples.load_from_cache(io, 1)
|
||||
# io.close()
|
||||
# self.assertEquals(prediction[0], "Hello Dunya")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
@ -13,7 +13,7 @@ os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"
|
||||
|
||||
class TestRoutes(unittest.TestCase):
|
||||
def setUp(self) -> None:
|
||||
self.io = Interface(lambda x: x, "text", "text")
|
||||
self.io = Interface(lambda x: x + x, "text", "text")
|
||||
self.app, _, _ = self.io.launch(prevent_thread_lock=True)
|
||||
self.client = TestClient(self.app)
|
||||
|
||||
@ -21,9 +21,9 @@ class TestRoutes(unittest.TestCase):
|
||||
response = self.client.get("/")
|
||||
self.assertEqual(response.status_code, 200)
|
||||
|
||||
def test_get_api_route(self):
|
||||
response = self.client.get("/api/")
|
||||
self.assertEqual(response.status_code, 200)
|
||||
# def test_get_api_route(self):
|
||||
# response = self.client.get("/api/")
|
||||
# self.assertEqual(response.status_code, 200)
|
||||
|
||||
def test_static_files_served_safely(self):
|
||||
# Make sure things outside the static folder are not accessible
|
||||
@ -37,12 +37,12 @@ class TestRoutes(unittest.TestCase):
|
||||
self.assertEqual(response.status_code, 200)
|
||||
|
||||
def test_predict_route(self):
|
||||
response = self.client.post("/api/predict/", json={"data": ["test"]})
|
||||
response = self.client.post(
|
||||
"/api/predict/", json={"data": ["test"], "fn_index": 0}
|
||||
)
|
||||
self.assertEqual(response.status_code, 200)
|
||||
output = dict(response.json())
|
||||
self.assertEqual(output["data"], ["test"])
|
||||
self.assertTrue("durations" in output)
|
||||
self.assertTrue("avg_durations" in output)
|
||||
self.assertEqual(output["data"], ["testtest"])
|
||||
|
||||
def test_queue_push_route(self):
|
||||
queueing.push = mock.MagicMock(return_value=(None, None))
|
||||
|
||||
Loading…
Reference in New Issue
Block a user