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.in_memory_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_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 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 in_memory_file_manager) afile = in_memory_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 InMemoryFileManager and test its properties. file_id = _calculate_file_id(fake_audio_data, "audio/wav") self.assertTrue(file_id in in_memory_file_manager) afile = in_memory_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_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 InMemoryFileManager and test its properties. file_id = _calculate_file_id(fake_video_data, "video/mp4") self.assertTrue(file_id in in_memory_file_manager) afile = in_memory_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.in_memory_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 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"), ) # Make sure we get different file ids for files with same bytes and mimetypes but diff't filenames. self.assertNotEqual( _calculate_file_id(fake_bytes, "audio/wav", file_name="name1.wav"), _calculate_file_id(fake_bytes, "audio/wav", file_name="name2.wav"), )
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 in_memory_file_manager) afile = in_memory_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.in_memory_file_manager.add(sample["content"], sample["mimetype"], coord) file_id = _calculate_file_id(sample["content"], sample["mimetype"]) self.assertTrue(file_id in self.in_memory_file_manager) mediafile = self.in_memory_file_manager.add(sample["content"], sample["mimetype"], coord) self.assertTrue(file_id in self.in_memory_file_manager) self.assertEqual(mediafile.id, file_id) # There should only be 1 file in MFM. self.assertEqual(len(self.in_memory_file_manager), 1) # There should only be 1 session with registered files. self.assertEqual( len(self.in_memory_file_manager._files_by_session_and_coord), 1)