def validate_absolute_path(self, root, absolute_path): try: in_memory_file_manager.get(absolute_path) except KeyError: LOGGER.error("InMemoryFileManager: Missing file %s" % absolute_path) raise tornado.web.HTTPError(404, "not found") return absolute_path
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 set_extra_headers(self, path: str) -> None: """Add Content-Disposition header for downloadable files. Set header value to "attachment" indicating that file should be saved locally instead of displaying inline in browser. We also set filename to specify filename for downloaded file. Used for serve downloadable files, like files stored via st.download_button widget """ in_memory_file = in_memory_file_manager.get(path) if in_memory_file and in_memory_file.file_type == FILE_TYPE_DOWNLOADABLE: file_name = in_memory_file.file_name if not file_name: title = self.get_argument("title", "", True) title = unquote_plus(title) filename = generate_download_filename_from_title(title) file_name = ( f"{filename}{_get_extension_for_mimetype(in_memory_file.mimetype)}" ) try: file_name.encode("ascii") file_expr = 'filename="{}"'.format(file_name) except UnicodeEncodeError: file_expr = "filename*=utf-8''{}".format(quote(file_name)) self.set_header("Content-Disposition", f"attachment; {file_expr}")
def get_content(cls, abspath, start=None, end=None): LOGGER.debug("MediaFileHandler: GET %s" % abspath) try: # abspath is the hash as used `get_absolute_path` in_memory_file = in_memory_file_manager.get(abspath) except: LOGGER.error("InMemoryFileManager: Missing file %s" % abspath) return LOGGER.debug( "InMemoryFileManager: Sending %s file %s" % (in_memory_file.mimetype, abspath) ) # If there is no start and end, just return the full content if start is None and end is None: return in_memory_file.content if start is None: start = 0 if end is None: end = len(in_memory_file.content) # content is bytes that work just by slicing supplied by start and end return in_memory_file.content[start:end]
def get_content_size(self): abspath = self.absolute_path if abspath is None: return 0 in_memory_file = in_memory_file_manager.get(abspath) return in_memory_file.content_size
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_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 get_content_size(self): in_memory_file = in_memory_file_manager.get(self.absolute_path) return in_memory_file.content_size