def test_calculate_file_id(self):
"""Test that file_id generation from data works as expected."""
fake_bytes = "\x00\x00\xff\x00\x00\xff\x00\x00\xff\x00\x00\xff\x00".encode(
"utf-8")
test_hash = "2ba850426b188d25adc5a37ad313080c346f5e88e069e0807d0cdb2b"
self.assertEqual(test_hash, _calculate_file_id(fake_bytes,
"media/any"))
# Make sure we get different file ids for files with same bytes but diff't mimetypes.
self.assertNotEqual(
_calculate_file_id(fake_bytes, "audio/wav"),
_calculate_file_id(fake_bytes, "video/mp4"),
)
def test_st_image_PIL_array(self):
"""Test st.image with a PIL array."""
imgs = [
Image.new("RGB", (64, 64), color="red"),
Image.new("RGB", (64, 64), color="blue"),
Image.new("RGB", (64, 64), color="green"),
]
st.image(
imgs,
caption=["some caption"] * 3,
width=200,
use_column_width=True,
clamp=True,
output_format="PNG",
)
el = self.get_delta_from_queue().new_element
self.assertEqual(el.imgs.width, -2)
# locate resultant file in the file manager and check its metadata.
from streamlit.elements.image_proto import _PIL_to_bytes
for idx in range(len(imgs)):
file_id = _calculate_file_id(
_PIL_to_bytes(imgs[idx], format="PNG"), "image/png")
self.assertEqual(el.imgs.imgs[idx].caption, "some caption")
self.assertTrue(file_id in media_file_manager)
afile = media_file_manager.get(file_id)
self.assertEqual(afile.mimetype, "image/png")
self.assertEqual(afile.url, el.imgs.imgs[idx].url)
def test_st_audio(self):
"""Test st.audio."""
# Fake audio data: expect the resultant mimetype to be audio default.
fake_audio_data = "\x11\x22\x33\x44\x55\x66".encode("utf-8")
st.audio(fake_audio_data)
el = self.get_delta_from_queue().new_element
# locate resultant file in MediaFileManager and test its properties.
file_id = _calculate_file_id(fake_audio_data, "audio/wav")
self.assertTrue(file_id in media_file_manager)
afile = media_file_manager.get(file_id)
self.assertEqual(afile.mimetype, "audio/wav")
self.assertEqual(afile.url, el.audio.url)
# Test using generated data in a file-like object.
sampleRate = 44100
frequency = 440
length = 5
t = np.linspace(0, length,
sampleRate * length) # Produces a 5 second Audio-File
y = np.sin(frequency * 2 * np.pi * t) # Has frequency of 440Hz
wavfile.write("test.wav", sampleRate, y)
with io.open("test.wav", "rb") as f:
st.audio(f)
el = self.get_delta_from_queue().new_element
self.assertTrue(".wav" in el.audio.url)
os.remove("test.wav")
# Test using a URL instead of data
some_url = "https://www.soundhelix.com/examples/mp3/SoundHelix-Song-3.mp3"
st.audio(some_url)
el = self.get_delta_from_queue().new_element
self.assertEqual(el.audio.url, some_url)
# Test that a non-URL string is assumed to be a filename
bad_filename = "blah"
with self.assertRaises(FileNotFoundError):
st.audio(bad_filename)
# Test that we can use an empty/None value without error.
st.audio(None)
el = self.get_delta_from_queue().new_element
self.assertEqual(el.audio.url, "")
# Test that our other data types don't result in an error.
st.audio(b"bytes_data")
st.audio("str_data".encode("utf-8"))
st.audio(BytesIO(b"bytesio_data"))
st.audio(np.array([0, 1, 2, 3]))
def test_marshall_images(self, data_in, format):
"""Test streamlit.image.marshall_images.
Need to test the following:
* if list
* if not list (is rgb vs is bgr)
* if captions is not list but image is
* if captions length doesnt match image length
* if the caption is set.
* PIL Images
* Numpy Arrays
* Url
* Path
* Bytes
"""
from streamlit.media_file_manager import _calculate_file_id
from streamlit.elements.image import _np_array_to_bytes
file_id = _calculate_file_id(
_np_array_to_bytes(data_in, output_format=format),
mimetype="image/" + format,
)
st.image(data_in, output_format=format)
imglist = self.get_delta_from_queue().new_element.imgs
self.assertEqual(len(imglist.imgs), 1)
self.assertTrue(imglist.imgs[0].url.startswith("/media"))
self.assertTrue(imglist.imgs[0].url.endswith(f".{format}"))
self.assertTrue(file_id in imglist.imgs[0].url)
def test_st_video(self):
"""Test st.video."""
# Make up some bytes to pretend we have a video. The server should not vet
# the video before sending it to the browser.
fake_video_data = "\x12\x10\x35\x44\x55\x66".encode("utf-8")
st.video(fake_video_data)
el = self.get_delta_from_queue().new_element
# locate resultant file in MediaFileManager and test its properties.
file_id = _calculate_file_id(fake_video_data, "video/mp4")
self.assertTrue(file_id in media_file_manager)
afile = media_file_manager.get(file_id)
self.assertEqual(afile.mimetype, "video/mp4")
self.assertEqual(afile.url, el.video.url)
# Test with an arbitrary URL in place of data
some_url = "http://www.marmosetcare.com/video/in-the-wild/intro.webm"
st.video(some_url)
el = self.get_delta_from_queue().new_element
self.assertEqual(el.video.url, some_url)
# Test with sufficiently varied youtube URLs
yt_urls = (
"https://youtu.be/_T8LGqJtuGc",
"https://www.youtube.com/watch?v=kmfC-i9WgH0",
"https://www.youtube.com/embed/sSn4e1lLVpA",
)
yt_embeds = (
"https://www.youtube.com/embed/_T8LGqJtuGc",
"https://www.youtube.com/embed/kmfC-i9WgH0",
"https://www.youtube.com/embed/sSn4e1lLVpA",
)
# url should be transformed into an embed link (or left alone).
for x in range(0, len(yt_urls)):
st.video(yt_urls[x])
el = self.get_delta_from_queue().new_element
self.assertEqual(el.video.url, yt_embeds[x])
# Test that a non-URL string is assumed to be a filename
bad_filename = "blah"
with self.assertRaises(FileNotFoundError):
st.video(bad_filename)
# Test that we can use an empty/None value without error.
st.video(None)
el = self.get_delta_from_queue().new_element
self.assertEqual(el.video.url, "")
# Test that our other data types don't result in an error.
st.video(b"bytes_data")
st.video("str_data".encode("utf-8"))
st.video(BytesIO(b"bytesio_data"))
st.video(np.array([0, 1, 2, 3]))
def test_st_audio_options(self):
"""Test st.audio with options."""
from streamlit.media_file_manager import _calculate_file_id
fake_audio_data = "\x11\x22\x33\x44\x55\x66".encode("utf-8")
st.audio(fake_audio_data, format="audio/mp3", start_time=10)
el = self.get_delta_from_queue().new_element
self.assertEqual(el.audio.start_time, 10)
self.assertTrue(el.audio.url.startswith(STATIC_MEDIA_ENDPOINT))
self.assertTrue(_calculate_file_id(fake_audio_data, "audio/mp3"), el.audio.url)
def np_audio(np_array, stem_name, samplerate=44100):
soundfile.write('temp.wav', np_array, samplerate, 'PCM_24')
st.audio('temp.wav', format='audio/wav')
with open("temp.wav", "rb") as f:
file_id = _calculate_file_id(f.read(), "audio/wav")
wav_url = f'{STATIC_MEDIA_ENDPOINT}/{file_id}.wav'
stem_urls.append({
'src': wav_url,
'name': stem_name,
'customClass': stem_name,
})
def test_st_image_PIL_image(self):
"""Test st.image with PIL image."""
img = Image.new("RGB", (64, 64), color="red")
st.image(img, caption="some caption", width=100, output_format="PNG")
el = self.get_delta_from_queue().new_element
self.assertEqual(el.imgs.width, 100)
self.assertEqual(el.imgs.imgs[0].caption, "some caption")
# locate resultant file in the file manager and check its metadata.
from streamlit.elements.image import _PIL_to_bytes
file_id = _calculate_file_id(_PIL_to_bytes(img, format="PNG"), "image/png")
self.assertTrue(file_id in media_file_manager)
afile = media_file_manager.get(file_id)
self.assertEqual(afile.mimetype, "image/png")
self.assertEqual(afile.url, el.imgs.imgs[0].url)
def test_add_file_already_exists_same_coord(self, _get_session_id):
_get_session_id.return_value = "SESSION1"
sample = IMAGE_FIXTURES["png"]
coord = random_coordinates()
self.mfm.add(sample["content"], sample["mimetype"], coord)
file_id = _calculate_file_id(sample["content"], sample["mimetype"])
self.assertTrue(file_id in self.mfm)
mediafile = self.mfm.add(sample["content"], sample["mimetype"], coord)
self.assertTrue(file_id in self.mfm)
self.assertEqual(mediafile.id, file_id)
# There should only be 1 file in MFM.
self.assertEqual(len(self.mfm), 1)
# There should only be 1 session with registered files.
self.assertEqual(len(self.mfm._files_by_session_and_coord), 1)