def test_format_manager():
""" Test working of the format manager """
formats = imageio.formats
# Test basics of FormatManager
assert isinstance(formats, FormatManager)
assert len(formats) > 0
assert 'FormatManager' in repr(formats)
# Get docs
smalldocs = str(formats)
#fulldocs = formats.create_docs_for_all_formats()
# Check each format ...
for format in formats:
# That each format is indeed a Format
assert isinstance(format, Format)
# That they are mentioned
assert format.name in smalldocs
#assert format.name in fulldocs
fname = get_remote_file('images/chelsea.png', test_dir)
fname2 = fname[:-3] + 'noext'
shutil.copy(fname, fname2)
# Check getting
F1 = formats['PNG']
F2 = formats['.png']
F3 = formats[fname2] # will look in file itself
assert F1 is F2
assert F1 is F3
# Check getting
F1 = formats['DICOM']
F2 = formats['.dcm']
F3 = formats['dcm'] # If omitting dot, format is smart enough to try with
assert F1 is F2
assert F1 is F3
# Fail
raises(ValueError, formats.__getitem__, 678) # must be str
raises(IndexError, formats.__getitem__, '.nonexistentformat')
# Adding a format
myformat = Format('test', 'test description', 'testext1 testext2')
formats.add_format(myformat)
assert myformat in [f for f in formats]
assert formats['testext1'] is myformat
assert formats['testext2'] is myformat
# Fail
raises(ValueError, formats.add_format, 678) # must be Format
raises(ValueError, formats.add_format, myformat) # cannot add twice
# Test searchinhg for read / write format
F = formats.search_read_format(Request(fname, 'ri'))
assert F is formats['PNG']
F = formats.search_save_format(Request(fname, 'wi'))
assert F is formats['PNG']
def test_lytro_raw_format():
"""
Test basic read/write properties of LytroRawFormat
"""
# Get test images
need_internet()
lfr_file = get_remote_file(LFR_FILENAME)
raw_file = get_remote_file(RAW_FILENAME)
png_file = get_remote_file(PNG_FILENAME)
# Test lytro raw format
format = imageio.formats['lytro-raw']
assert format.name == 'LYTRO-RAW'
assert format.__module__.endswith('lytro')
# Test can read, cannot write
assert format.can_read(Request(raw_file, 'ri'))
# Test cannot read, cannot write
assert not format.can_read(Request(raw_file, 'rv'))
assert not format.can_read(Request(raw_file, 'rI'))
assert not format.can_read(Request(raw_file, 'rV'))
assert not format.can_read(Request(lfr_file, 'ri'))
assert not format.can_read(Request(png_file, 'ri'))
assert not format.can_write(Request(raw_file, 'wi'))
assert not format.can_write(Request(lfr_file, 'wi'))
assert not format.can_write(Request(png_file, 'wi'))
def test_fits_format():
# Test selection
for name in ['fits', '.fits']:
format = imageio.formats['fits']
assert format.name == 'FITS'
assert format.__module__.endswith('.fits')
# Test cannot read
png = get_remote_file('images/chelsea.png')
assert not format.can_read(Request(png, 'ri'))
assert not format.can_write(Request(png, 'wi'))
def test_npz_format():
# Test selection
for name in ['npz', '.npz']:
format = imageio.formats['npz']
assert format.name == 'NPZ'
assert format.__module__.endswith('.npz')
# Test cannot read
png = get_remote_file('images/chelsea.png')
assert not format._can_read(Request(png, 'ri'))
assert not format._can_save(Request(png, 'wi'))
def test_npz_format(test_images):
# Test selection
for name in ["npz", ".npz"]:
format = imageio.formats["npz"]
assert format.name == "NPZ"
assert format.__module__.endswith(".npz")
# Test cannot read
png = test_images / "chelsea.png"
assert not format.can_read(Request(png, "ri"))
assert not format.can_write(Request(png, "wi"))
def test_fits_format():
need_internet() # We keep the fits files in the imageio-binary repo
# Test selection
for name in ["fits", ".fits"]:
format = imageio.formats["fits"]
assert format.name == "FITS"
assert format.__module__.endswith(".fits")
# Test cannot read
png = get_remote_file("images/chelsea.png")
assert not format.can_read(Request(png, "ri"))
assert not format.can_write(Request(png, "wi"))
def test_example_plugin():
""" Test the example plugin """
fname = os.path.join(test_dir, 'out.png')
R = imageio.formats['dummy'].read(Request('chelsea.png', 'r?'))
W = imageio.formats['dummy'].save(Request(fname, 'w?'))
#
assert len(R) == 1
assert R.get_data(0).ndim
raises(IndexError, R.get_data, 1)
#raises(RuntimeError, R.get_meta_data)
assert R.get_meta_data() == {}
R.close()
#
raises(RuntimeError, W.append_data, np.zeros((10, 10)))
raises(RuntimeError, W.set_meta_data, {})
W.close()
def test_example_plugin():
""" Test the example plugin """
fname = os.path.join(test_dir, "out.png")
r = Request("imageio:chelsea.png", "r?")
R = imageio.formats["dummy"].get_reader(r)
W = imageio.formats["dummy"].get_writer(Request(fname, "w?"))
#
assert len(R) == 1
assert R.get_data(0).ndim
raises(IndexError, R.get_data, 1)
# raises(RuntimeError, R.get_meta_data)
assert R.get_meta_data() == {}
R.close()
#
raises(RuntimeError, W.append_data, np.zeros((10, 10)))
raises(RuntimeError, W.set_meta_data, {})
W.close()
def test_request_read_sources():
# Make an image available in many ways
fname = "images/chelsea.png"
filename = get_remote_file(fname, test_dir)
bytes = open(filename, "rb").read()
#
burl = "https://raw.githubusercontent.com/imageio/imageio-binaries/master/"
zipfilename = os.path.join(test_dir, "test1.zip")
with ZipFile(zipfilename, "w") as zf:
zf.writestr(fname, bytes)
has_inet = os.getenv("IMAGEIO_NO_INTERNET", "") not in ("1", "yes", "true")
# Read that image from these different sources. Read data from file
# and from local file (the two main plugin-facing functions)
for file_or_filename in range(2):
for check_first_bytes in range(2):
# Define uris to test. Define inside loop, since we need fresh files
uris = [
filename,
os.path.join(zipfilename, fname),
bytes,
memoryview(bytes),
open(filename, "rb"),
]
if has_inet:
uris.append(burl + fname)
for uri in uris:
R = Request(uri, "ri")
if check_first_bytes:
first_bytes = R.firstbytes
if file_or_filename == 0:
all_bytes = R.get_file().read()
else:
with open(R.get_local_filename(), "rb") as f:
all_bytes = f.read()
R.finish()
assert bytes == all_bytes
if check_first_bytes:
assert len(first_bytes) > 0
assert all_bytes.startswith(first_bytes)
def test_format_selection():
formats = imageio.formats
fname1 = get_remote_file("images/chelsea.png", test_dir)
fname2 = os.path.join(test_dir, "test.selectext1")
fname3 = os.path.join(test_dir, "test.haha")
open(fname2, "wb")
open(fname3, "wb")
# Test searchinhg for read / write format
F = formats.search_read_format(Request(fname1, "ri"))
assert F is formats["PNG"]
F = formats.search_write_format(Request(fname1, "wi"))
assert F is formats["PNG"]
# Now with custom format
format = MyFormat("test_selection", "xx", "selectext1", "i")
formats.add_format(format)
# Select this format for files it said it could handle in extensions
assert ".selectext1" in fname2
F = formats.search_read_format(Request(fname2, "ri"))
assert F is format
F = formats.search_write_format(Request(fname2, "ri"))
assert F is format
# But this custom format also can deal with .haha files
assert ".haha" in fname3
F = formats.search_read_format(Request(fname3, "ri"))
assert F is format
F = formats.search_write_format(Request(fname3, "ri"))
assert F is format
def test_format_selection(test_images, tmp_path):
formats = imageio.formats
fname1 = test_images / "chelsea.png"
fname2 = tmp_path / "test.selectext1"
fname3 = tmp_path / "test.haha"
open(fname2, "wb")
open(fname3, "wb")
# Test searchinhg for read / write format
F = formats.search_read_format(Request(fname1, "ri"))
assert isinstance(F, type(formats["PNG"]))
F = formats.search_write_format(Request(fname1, "wi"))
assert isinstance(F, type(formats["PNG"]))
# Now with custom format
format = MyFormat("test_selection", "xx", "selectext1", "i")
formats.add_format(format)
# Select this format for files it said it could handle in extensions
assert ".selectext1" in str(fname2)
F = formats.search_read_format(Request(fname2, "ri"))
assert type(F) is type(format)
F = formats.search_write_format(Request(fname2, "ri"))
assert type(F) is type(format)
# But this custom format also can deal with .haha files
assert ".haha" in str(fname3)
F = formats.search_read_format(Request(fname3, "ri"))
assert type(F) is type(format)
F = formats.search_write_format(Request(fname3, "ri"))
assert type(F) is type(format)
def test_format_selection():
formats = imageio.formats
fname1 = get_remote_file('images/chelsea.png', test_dir)
fname2 = os.path.join(test_dir, 'test.selectext1')
fname3 = os.path.join(test_dir, 'test.haha')
open(fname2, 'wb')
open(fname3, 'wb')
# Test searchinhg for read / write format
F = formats.search_read_format(Request(fname1, 'ri'))
assert F is formats['PNG']
F = formats.search_write_format(Request(fname1, 'wi'))
assert F is formats['PNG']
# Now with custom format
format = MyFormat('test_selection', 'xx', 'selectext1', 'i')
formats.add_format(format)
# Select this format for files it said it could handle in extensions
assert '.selectext1' in fname2
F = formats.search_read_format(Request(fname2, 'ri'))
assert F is format
F = formats.search_write_format(Request(fname2, 'ri'))
assert F is format
# But this custom format also can deal with .haha files
assert '.haha' in fname3
F = formats.search_read_format(Request(fname3, 'ri'))
assert F is format
F = formats.search_write_format(Request(fname3, 'ri'))
assert F is format
def test_request_read_sources():
# Make an image available in many ways
fname = 'images/chelsea.png'
filename = get_remote_file(fname, test_dir)
bytes = open(filename, 'rb').read()
#
burl = 'https://raw.githubusercontent.com/imageio/imageio-binaries/master/'
z = ZipFile(os.path.join(test_dir, 'test.zip'), 'w')
z.writestr(fname, bytes)
z.close()
has_inet = os.getenv('IMAGEIO_NO_INTERNET', '') not in ('1', 'yes', 'true')
# Read that image from these different sources. Read data from file
# and from local file (the two main plugin-facing functions)
for X in range(2):
# Define uris to test. Define inside loop, since we need fresh files
uris = [filename,
os.path.join(test_dir, 'test.zip', fname),
bytes,
open(filename, 'rb')]
if has_inet:
uris.append(burl + fname)
for uri in uris:
R = Request(uri, 'ri')
first_bytes = R.firstbytes
if X == 0:
all_bytes = R.get_file().read()
else:
f = open(R.get_local_filename(), 'rb')
all_bytes = f.read()
R.finish()
# Test
assert len(first_bytes) > 0
assert all_bytes.startswith(first_bytes)
assert bytes == all_bytes
def test_request_save_sources():
# Get test data
fname = "images/chelsea.png"
filename = get_remote_file(fname, test_dir)
with open(filename, "rb") as f:
bytes = f.read()
assert len(bytes) > 0
# Prepare destinations
fname2 = fname + ".out"
filename2 = os.path.join(test_dir, fname2)
zipfilename2 = os.path.join(test_dir, "test2.zip")
file2 = None
# Write an image into many different destinations
# Do once via file and ones via local filename
for file_or_filename in range(2):
# Clear destinations
for xx in (filename2, zipfilename2):
if os.path.isfile(xx):
os.remove(xx)
file2 = BytesIO()
# Write to four destinations
for uri in (
filename2,
os.path.join(zipfilename2, fname2),
file2,
imageio.RETURN_BYTES, # This one last to fill `res`
):
R = Request(uri, "wi")
if file_or_filename == 0:
R.get_file().write(bytes) # via file
else:
with open(R.get_local_filename(), "wb") as f:
f.write(bytes) # via local
R.finish()
res = R.get_result()
# Test four results
with open(filename2, "rb") as f:
assert f.read() == bytes
with ZipFile(zipfilename2, "r") as zf:
assert zf.open(fname2).read() == bytes
assert file2.getvalue() == bytes
assert res == bytes
def test_request_file_no_seek():
class File:
def read(self, n):
return b"\x00" * n
def seek(self, i):
raise IOError("Not supported")
def tell(self):
raise Exception("Not supported")
def close(self):
pass
R = Request(File(), "ri")
with raises(IOError):
R.firstbytes
def test_request_file_no_seek():
class File:
def read(self, n):
return b'\x00' * n
def seek(self, i):
raise IOError('Not supported')
def tell(self):
raise Exception('Not supported')
def close(self):
pass
R = Request(File(), 'ri')
with raises(IOError):
R.firstbytes
def test_default_can_read_and_can_write():
F = imageio.plugins.example.DummyFormat("test", "", "foo bar", "v")
# Prepare files
filename1 = os.path.join(test_dir, "test")
open(filename1 + ".foo", "wb")
open(filename1 + ".bar", "wb")
open(filename1 + ".spam", "wb")
# Test _can_read()
assert F.can_read(Request(filename1 + ".foo", "rv"))
assert F.can_read(Request(filename1 + ".bar", "r?"))
assert not F.can_read(Request(filename1 + ".spam", "r?"))
assert not F.can_read(Request(filename1 + ".foo", "ri"))
# Test _can_write()
assert F.can_write(Request(filename1 + ".foo", "wv"))
assert F.can_write(Request(filename1 + ".bar", "w?"))
assert not F.can_write(Request(filename1 + ".spam", "w?"))
assert not F.can_write(Request(filename1 + ".foo", "wi"))
def test_default_can_read_and_can_write():
F = imageio.plugins.example.DummyFormat('test', '', 'foo bar', 'v')
# Prepare files
filename1 = os.path.join(test_dir, 'test')
open(filename1 + '.foo', 'wb')
open(filename1 + '.bar', 'wb')
open(filename1 + '.spam', 'wb')
# Test _can_read()
assert F.can_read(Request(filename1 + '.foo', 'rv'))
assert F.can_read(Request(filename1 + '.bar', 'r?'))
assert not F.can_read(Request(filename1 + '.spam', 'r?'))
assert not F.can_read(Request(filename1 + '.foo', 'ri'))
# Test _can_write()
assert F.can_write(Request(filename1 + '.foo', 'wv'))
assert F.can_write(Request(filename1 + '.bar', 'w?'))
assert not F.can_write(Request(filename1 + '.spam', 'w?'))
assert not F.can_write(Request(filename1 + '.foo', 'wi'))
def test_request_save_sources():
# Get test data
fname = "images/chelsea.png"
filename = get_remote_file(fname, test_dir)
with open(filename, "rb") as f:
bytes = f.read()
assert len(bytes) > 0
# Prepare destinations
fname2 = fname + ".out"
filename2 = os.path.join(test_dir, fname2)
zipfilename2 = os.path.join(test_dir, "test2.zip")
file2 = None
# Write an image into many different destinations
# Do once via file and ones via local filename
for file_or_filename in range(2):
# Clear destinations
for xx in (filename2, zipfilename2):
if os.path.isfile(xx):
os.remove(xx)
file2 = BytesIO()
# Write to four destinations
for uri in (
filename2,
os.path.join(zipfilename2, fname2),
file2,
imageio.RETURN_BYTES, # This one last to fill `res`
):
R = Request(uri, "wi")
if file_or_filename == 0:
R.get_file().write(bytes) # via file
else:
with open(R.get_local_filename(), "wb") as f:
f.write(bytes) # via local
R.finish()
res = R.get_result()
# Test four results
with open(filename2, "rb") as f:
assert f.read() == bytes
with ZipFile(zipfilename2, "r") as zf:
assert zf.open(fname2).read() == bytes
assert file2.getvalue() == bytes
assert res == bytes
def test_request_save_sources():
# Prepare desinations
fname = 'images/chelsea.png'
filename = get_remote_file(fname, test_dir)
bytes = open(filename, 'rb').read()
#
fname2 = fname + '.out'
filename2 = os.path.join(test_dir, fname2)
zipfilename2 = os.path.join(test_dir, 'test.zip')
file2 = BytesIO()
# Write an image into many different destinations
# Do once via file and ones via local filename
for i in range(2):
# Clear
for xx in (filename2, zipfilename2):
if os.path.isfile(xx):
os.remove(xx)
# Write to three destinations
for uri in (
filename2,
os.path.join(zipfilename2, fname2),
file2,
imageio.RETURN_BYTES # This one last to fill `res`
):
R = Request(uri, 'wi')
if i == 0:
R.get_file().write(bytes) # via file
else:
open(R.get_local_filename(), 'wb').write(bytes) # via local
R.finish()
res = R.get_result()
# Test three results
assert open(filename2, 'rb').read() == bytes
assert ZipFile(zipfilename2, 'r').open(fname2).read() == bytes
assert res == bytes
def test_request_read_sources():
# Make an image available in many ways
fname = "images/chelsea.png"
filename = get_remote_file(fname, test_dir)
bytes = open(filename, "rb").read()
#
burl = "https://raw.githubusercontent.com/imageio/imageio-binaries/master/"
zipfilename = os.path.join(test_dir, "test1.zip")
with ZipFile(zipfilename, "w") as zf:
zf.writestr(fname, bytes)
has_inet = os.getenv("IMAGEIO_NO_INTERNET", "") not in ("1", "yes", "true")
# Read that image from these different sources. Read data from file
# and from local file (the two main plugin-facing functions)
for file_or_filename in range(2):
for check_first_bytes in range(2):
# Define uris to test. Define inside loop, since we need fresh files
uris = [
filename,
os.path.join(zipfilename, fname),
bytes,
memoryview(bytes),
open(filename, "rb"),
]
if has_inet:
uris.append(burl + fname)
for uri in uris:
R = Request(uri, "ri")
if check_first_bytes:
first_bytes = R.firstbytes
if file_or_filename == 0:
all_bytes = R.get_file().read()
else:
with open(R.get_local_filename(), "rb") as f:
all_bytes = f.read()
R.finish()
assert bytes == all_bytes
if check_first_bytes:
assert len(first_bytes) > 0
assert all_bytes.startswith(first_bytes)
def test_request_save_sources():
# Prepare desinations
fname = 'images/chelsea.png'
filename = get_remote_file(fname, test_dir)
bytes = open(filename, 'rb').read()
#
fname2 = fname + '.out'
filename2 = os.path.join(test_dir, fname2)
zipfilename2 = os.path.join(test_dir, 'test.zip')
file2 = BytesIO()
# Write an image into many different destinations
# Do once via file and ones via local filename
for i in range(2):
# Clear
for xx in (filename2, zipfilename2):
if os.path.isfile(xx):
os.remove(xx)
# Write to three destinations
for uri in (filename2,
os.path.join(zipfilename2, fname2),
file2,
imageio.RETURN_BYTES # This one last to fill `res`
):
R = Request(uri, 'wi')
if i == 0:
R.get_file().write(bytes) # via file
else:
open(R.get_local_filename(), 'wb').write(bytes) # via local
R.finish()
res = R.get_result()
# Test three results
assert open(filename2, 'rb').read() == bytes
assert ZipFile(zipfilename2, 'r').open(fname2).read() == bytes
assert res == bytes
def test_request_read_sources(test_images, tmp_userdir):
# Make an image available in many ways
fname = "chelsea.png"
filename = test_images / fname
bytes = open(str(filename), "rb").read()
#
burl = "https://raw.githubusercontent.com/imageio/test_images/master/"
zipfilename = tmp_userdir / "test1.zip"
with ZipFile(zipfilename, "w") as zf:
zf.writestr(fname, bytes)
# Read that image from these different sources. Read data from file
# and from local file (the two main plugin-facing functions)
for file_or_filename in range(2):
for check_first_bytes in range(2):
# Define uris to test. Define inside loop, since we need fresh files
uris = [
filename,
os.path.join(zipfilename, fname),
bytes,
memoryview(bytes),
open(filename, "rb"),
]
uris.append(burl + fname)
for uri in uris:
R = Request(uri, "ri")
if check_first_bytes:
first_bytes = R.firstbytes
if file_or_filename == 0:
all_bytes = R.get_file().read()
else:
with open(R.get_local_filename(), "rb") as f:
all_bytes = f.read()
R.finish()
assert bytes == all_bytes
if check_first_bytes:
assert len(first_bytes) > 0
assert all_bytes.startswith(first_bytes)
def test_request_read_sources():
# Make an image available in many ways
fname = 'images/chelsea.png'
filename = get_remote_file(fname, test_dir)
bytes = open(filename, 'rb').read()
#
burl = 'https://raw.githubusercontent.com/imageio/imageio-binaries/master/'
z = ZipFile(os.path.join(test_dir, 'test.zip'), 'w')
z.writestr(fname, bytes)
z.close()
has_inet = os.getenv('IMAGEIO_NO_INTERNET', '') not in ('1', 'yes', 'true')
# Read that image from these different sources. Read data from file
# and from local file (the two main plugin-facing functions)
for X in range(2):
# Define uris to test. Define inside loop, since we need fresh files
uris = [
filename,
os.path.join(test_dir, 'test.zip', fname), bytes,
open(filename, 'rb')
]
if has_inet:
uris.append(burl + fname)
for uri in uris:
R = Request(uri, 'ri')
first_bytes = R.firstbytes
if X == 0:
all_bytes = R.get_file().read()
else:
f = open(R.get_local_filename(), 'rb')
all_bytes = f.read()
R.finish()
# Test
assert len(first_bytes) > 0
assert all_bytes.startswith(first_bytes)
assert bytes == all_bytes
def test_request():
""" Test request object """
# Check uri-type, this is not a public property, so we test the private
R = Request("http://example.com", "ri")
assert R._uri_type == core.request.URI_HTTP
R = Request("ftp://example.com", "ri")
assert R._uri_type == core.request.URI_FTP
R = Request("file://~/foo.png", "wi")
assert R._uri_type == core.request.URI_FILENAME
R = Request("<video0>", "rI")
assert R._uri_type == core.request.URI_BYTES
R = Request(imageio.RETURN_BYTES, "wi")
assert R._uri_type == core.request.URI_BYTES
#
fname = get_remote_file("images/chelsea.png", test_dir)
R = Request(fname, "ri")
assert R._uri_type == core.request.URI_FILENAME
R = Request("~/filethatdoesnotexist", "wi")
assert R._uri_type == core.request.URI_FILENAME # Too short to be bytes
R = Request(b"x" * 600, "ri")
assert R._uri_type == core.request.URI_BYTES
R = Request(sys.stdin, "ri")
assert R._uri_type == core.request.URI_FILE
R = Request(sys.stdout, "wi")
assert R._uri_type == core.request.URI_FILE
# exapand user dir
R = Request("~/foo", "wi")
assert R.filename == os.path.expanduser("~/foo").replace("/", os.path.sep)
# zip file
R = Request("~/bar.zip/spam.png", "wi")
assert R._uri_type == core.request.URI_ZIPPED
# Test failing inits
raises(ValueError, Request, "/some/file", None) # mode must be str
raises(ValueError, Request, "/some/file", 3) # mode must be str
raises(ValueError, Request, "/some/file", "") # mode must be len 2
raises(ValueError, Request, "/some/file", "r") # mode must be len 2
raises(ValueError, Request, "/some/file", "rii") # mode must be len 2
raises(ValueError, Request, "/some/file", "xi") # mode[0] must be in rw
raises(ValueError, Request, "/some/file", "rx") # mode[1] must be in iIvV?
#
raises(IOError, Request, ["invalid", "uri"] * 10, "ri") # invalid uri
raises(IOError, Request, 4, "ri") # invalid uri
# nonexistent reads
raises(FileNotFoundError, Request, "/does/not/exist", "ri")
raises(FileNotFoundError, Request, "/does/not/exist.zip/spam.png", "ri")
if Path is not None:
raises(FileNotFoundError, Request, Path("/does/not/exist"), "ri")
raises(IOError, Request, "http://example.com", "wi") # no writing here
# write dir nonexist
raises(FileNotFoundError, Request, "/does/not/exist.png", "wi")
if Path is not None:
raises(FileNotFoundError, Request, Path("/does/not/exist.png"), "wi")
# Test auto-download
R = Request("imageio:chelsea.png", "ri")
assert R.filename == get_remote_file("images/chelsea.png")
#
R = Request("imageio:chelsea.zip/chelsea.png", "ri")
assert R._filename_zip[0] == get_remote_file("images/chelsea.zip")
assert R.filename == get_remote_file("images/chelsea.zip") + "/chelsea.png"
# Test zip false-positive detection
with tempfile.TemporaryDirectory() as tmp_path:
bait_zip = os.path.join(tmp_path, "test.zip")
os.mkdir(bait_zip)
file_path = os.path.join(bait_zip, "foo.jpg")
chelsia = get_remote_file("images/chelsea.png")
shutil.copy(chelsia, file_path)
R = Request(file_path, "ri")
assert R._uri_type == core.request.URI_FILENAME
def test_lytro_f01_raw_format():
"""
Test basic read/write properties of LytroRawFormat
"""
# Get test images
need_internet()
lfr_file = get_remote_file(LFR_FILENAME)
raw_illum_file = get_remote_file(RAW_ILLUM_FILENAME)
lfp_file = get_remote_file(LFP_FILENAME)
raw_f01_file = get_remote_file(RAW_F0_FILENAME)
png_file = get_remote_file(PNG_FILENAME)
# Test lytro raw format
format = imageio.formats["lytro-illum-raw"]
assert format.name == "LYTRO-ILLUM-RAW"
assert format.__module__.endswith("lytro")
# Test can read, cannot write
assert format.can_read(Request(raw_f01_file, "ri"))
# Test cannot read, cannot write
assert not format.can_read(Request(raw_f01_file, "rv"))
assert not format.can_read(Request(raw_f01_file, "rI"))
assert not format.can_read(Request(raw_f01_file, "rV"))
assert not format.can_read(Request(lfr_file, "ri"))
assert not format.can_read(Request(lfp_file, "ri"))
assert not format.can_read(Request(png_file, "ri"))
assert not format.can_write(Request(raw_f01_file, "wi"))
assert not format.can_write(Request(lfr_file, "wi"))
assert not format.can_write(Request(lfp_file, "wi"))
assert not format.can_write(Request(raw_illum_file, "wi"))
assert not format.can_write(Request(png_file, "wi"))
def test_lytro_lfr_format():
"""
Test basic read/write properties of LytroLfrFormat
"""
# Get test images
need_internet()
lfr_file = get_remote_file(LFR_FILENAME)
raw_illum_file = get_remote_file(RAW_ILLUM_FILENAME)
lfp_file = get_remote_file(LFP_FILENAME)
raw_f01_file = get_remote_file(RAW_F0_FILENAME)
png_file = get_remote_file(PNG_FILENAME)
# Test lytro lfr format
format = imageio.formats['lytro-lfr']
assert format.name == 'LYTRO-LFR'
assert format.__module__.endswith('lytro')
# Test can read
assert format.can_read(Request(lfr_file, 'ri'))
# Test cannot read, cannot write
assert not format.can_read(Request(lfr_file, 'rv'))
assert not format.can_read(Request(lfr_file, 'rI'))
assert not format.can_read(Request(lfr_file, 'rV'))
assert not format.can_read(Request(lfp_file, 'ri'))
assert not format.can_read(Request(raw_illum_file, 'ri'))
assert not format.can_read(Request(raw_f01_file, 'ri'))
assert not format.can_read(Request(png_file, 'ri'))
assert not format.can_write(Request(lfr_file, 'wi'))
assert not format.can_write(Request(lfp_file, 'wi'))
assert not format.can_write(Request(raw_f01_file, 'wi'))
assert not format.can_write(Request(raw_illum_file, 'wi'))
assert not format.can_write(Request(png_file, 'wi'))
def test_request_read_sources():
# Make an image available in many ways
fname = 'images/chelsea.png'
filename = get_remote_file(fname, test_dir)
bytes = open(filename, 'rb').read()
#
burl = 'https://raw.githubusercontent.com/imageio/imageio-binaries/master/'
z = ZipFile(os.path.join(test_dir, 'test.zip'), 'w')
z.writestr(fname, bytes)
z.close()
file = open(filename, 'rb')
# Read that image from these different sources. Read data from file
# and from local file (the two main plugin-facing functions)
for uri in (filename,
os.path.join(test_dir, 'test.zip', fname),
bytes,
file,
burl + fname):
# Init
firsbytes_list, bytes_list = [], []
# Via file
R = Request(uri, 'ri')
firsbytes_list.append(R.firstbytes)
bytes_list.append(R.get_file().read())
R.finish()
# Via local filename
R = Request(uri, 'ri')
firsbytes_list.append(R.firstbytes)
f = open(R.get_local_filename(), 'rb')
bytes_list.append(f.read())
R.finish()
# Test repeated
if uri == filename:
bytes_list.append(R.get_file().read())
f = open(R.get_local_filename(), 'rb')
bytes_list.append(f.read())
R.finish()
# Test
for i in range(len(firsbytes_list)):
assert len(firsbytes_list[i]) > 0
assert bytes.startswith(firsbytes_list[i])
for i in range(len(bytes_list)):
assert bytes == bytes_list[i]
def test_format():
"""Test the working of the Format class"""
filename1 = get_remote_file("images/chelsea.png", test_dir)
filename2 = filename1 + ".out"
# Test basic format creation
F = Format("testname", "test description", "foo bar spam")
assert F.name == "TESTNAME"
assert F.description == "test description"
assert F.name in repr(F)
assert F.name in F.doc
assert str(F) == F.doc
assert set(F.extensions) == {".foo", ".bar", ".spam"}
# Test setting extensions
F1 = Format("test", "", "foo bar spam")
F2 = Format("test", "", "foo, bar,spam")
F3 = Format("test", "", ["foo", "bar", "spam"])
F4 = Format("test", "", ".foo .bar .spam")
for F in (F1, F2, F3, F4):
assert set(F.extensions) == {".foo", ".bar", ".spam"}
# Fail
raises(ValueError, Format, "test", "", 3) # not valid ext
raises(ValueError, Format, "test", "", "", 3) # not valid mode
raises(ValueError, Format, "test", "", "", "x") # not valid mode
# Test subclassing
F = MyFormat("test", "", modes="i")
assert "TEST DOCS" in F.doc
# Get and check reader and write classes
R = F.get_reader(Request(filename1, "ri"))
W = F.get_writer(Request(filename2, "wi"))
assert isinstance(R, MyFormat.Reader)
assert isinstance(W, MyFormat.Writer)
assert R.format is F
assert W.format is F
assert R.request.filename == filename1
assert W.request.filename == filename2
# Fail
raises(RuntimeError, F.get_reader, Request(filename1, "rI"))
raises(RuntimeError, F.get_writer, Request(filename2, "wI"))
# Use as context manager
with R:
pass
with W:
pass
# Objects are now closed, cannot be used
assert R.closed
assert W.closed
#
raises(RuntimeError, R.__enter__)
raises(RuntimeError, W.__enter__)
#
raises(RuntimeError, R.get_data, 0)
raises(RuntimeError, W.append_data, np.zeros((10, 10)))
# Test __del__
R = F.get_reader(Request(filename1, "ri"))
W = F.get_writer(Request(filename2, "wi"))
ids = id(R), id(W)
F._closed[:] = []
del R
del W
gc.collect() # Invoke __del__
assert set(ids) == set(F._closed)
def test_request():
""" Test request object """
# Check uri-type, this is not a public property, so we test the private
R = Request('http://example.com', 'ri')
assert R._uri_type == core.request.URI_HTTP
R = Request('ftp://example.com', 'ri')
assert R._uri_type == core.request.URI_FTP
R = Request('file://example.com', 'wi')
assert R._uri_type == core.request.URI_FILENAME
R = Request('<video0>', 'rI')
assert R._uri_type == core.request.URI_BYTES
R = Request(imageio.RETURN_BYTES, 'wi')
assert R._uri_type == core.request.URI_BYTES
#
fname = get_remote_file('images/chelsea.png', test_dir)
R = Request(fname, 'ri')
assert R._uri_type == core.request.URI_FILENAME
R = Request('/file/that/does/not/exist', 'wi')
assert R._uri_type == core.request.URI_FILENAME # Too short to be bytes
R = Request(b'x'*600, 'ri')
assert R._uri_type == core.request.URI_BYTES
R = Request(sys.stdin, 'ri')
assert R._uri_type == core.request.URI_FILE
R = Request(sys.stdout, 'wi')
assert R._uri_type == core.request.URI_FILE
# exapand user dir
R = Request('~/foo', 'wi')
assert R.filename == os.path.expanduser('~/foo')
# zip file
R = Request('/foo/bar.zip/spam.png', 'wi')
assert R._uri_type == core.request.URI_ZIPPED
# Test failing inits
raises(ValueError, Request, '/some/file', None) # mode must be str
raises(ValueError, Request, '/some/file', 3) # mode must be str
raises(ValueError, Request, '/some/file', '') # mode must be len 2
raises(ValueError, Request, '/some/file', 'r') # mode must be len 2
raises(ValueError, Request, '/some/file', 'rii') # mode must be len 2
raises(ValueError, Request, '/some/file', 'xi') # mode[0] must be in rw
raises(ValueError, Request, '/some/file', 'rx') # mode[1] must be in iIvV?
#
raises(IOError, Request, ['invalid', 'uri'] * 10, 'ri') # invalid uri
raises(IOError, Request, 4, 'ri') # invalid uri
raises(IOError, Request, '/does/not/exist', 'ri') # reading nonexistent
raises(IOError, Request, '/does/not/exist.zip/spam.png', 'ri') # dito
raises(IOError, Request, 'http://example.com', 'wi') # no writing here
# Test auto-download
R = Request('chelsea.png', 'ri')
assert R.filename == get_remote_file('images/chelsea.png')
R = Request('chelsea.zip/chelsea.png', 'ri')
assert R._filename_zip[0] == get_remote_file('images/chelsea.zip')
assert R.filename == get_remote_file('images/chelsea.zip') + '/chelsea.png'
# Make an image available in many ways
burl = 'https://raw.githubusercontent.com/imageio/imageio-binaries/master/'
fname = 'images/chelsea.png'
filename = get_remote_file(fname, test_dir)
bytes = open(filename, 'rb').read()
z = ZipFile(os.path.join(test_dir, 'test.zip'), 'w')
z.writestr(fname, bytes)
z.close()
file = open(filename, 'rb')
# Read that image from these different sources. Read data from file
# and from local file (the two main plugin-facing functions)
for uri in (filename,
os.path.join(test_dir, 'test.zip', fname),
bytes,
file,
burl + fname):
# Init
firsbytes_list, bytes_list = [], []
# Via file
R = Request(uri, 'ri')
firsbytes_list.append(R.firstbytes)
bytes_list.append(R.get_file().read())
R.finish()
# Via local filename
R = Request(uri, 'ri')
firsbytes_list.append(R.firstbytes)
f = open(R.get_local_filename(), 'rb')
bytes_list.append(f.read())
R.finish()
# Test repeated
if uri == filename:
bytes_list.append(R.get_file().read())
f = open(R.get_local_filename(), 'rb')
bytes_list.append(f.read())
R.finish()
# Test
for i in range(len(firsbytes_list)):
assert len(firsbytes_list[i]) > 0
assert bytes.startswith(firsbytes_list[i])
for i in range(len(bytes_list)):
assert bytes == bytes_list[i]
# Prepare desinations
fname2 = fname + '.out'
filename2 = os.path.join(test_dir, fname2)
zipfilename2 = os.path.join(test_dir, 'test.zip')
file2 = BytesIO()
# Write an image into many different destinations
# Do once via file and ones via local filename
for i in range(2):
# Clear
for xx in (filename2, zipfilename2):
if os.path.isfile(xx):
os.remove(xx)
# Write to three destinations
for uri in (filename2,
os.path.join(zipfilename2, fname2),
file2,
imageio.RETURN_BYTES # This one last to fill `res`
):
R = Request(uri, 'wi')
if i == 0:
R.get_file().write(bytes) # via file
else:
open(R.get_local_filename(), 'wb').write(bytes) # via local
R.finish()
res = R.get_result()
# Test three results
assert open(filename2, 'rb').read() == bytes
assert ZipFile(zipfilename2, 'r').open(fname2).read() == bytes
assert res == bytes
def test_lytro_illum_raw_format(test_images):
"""
Test basic read/write properties of LytroRawFormat
"""
# Get test images
lfr_file = test_images / LFR_FILENAME
raw_illum_file = test_images / RAW_ILLUM_FILENAME
lfp_file = test_images / LFP_FILENAME
raw_f01_file = test_images / RAW_F0_FILENAME
png_file = test_images / PNG_FILENAME
# Test lytro raw format
format = imageio.formats["lytro-illum-raw"]
assert format.name == "LYTRO-ILLUM-RAW"
assert format.__module__.endswith("lytro")
# Test can read, cannot write
assert format.can_read(Request(raw_illum_file, "ri"))
# Test cannot read, cannot write
assert not format.can_read(Request(raw_illum_file, "rv"))
assert not format.can_read(Request(raw_illum_file, "rI"))
assert not format.can_read(Request(raw_illum_file, "rV"))
assert not format.can_read(Request(lfr_file, "ri"))
assert not format.can_read(Request(lfp_file, "ri"))
assert not format.can_read(Request(png_file, "ri"))
assert not format.can_write(Request(raw_illum_file, "wi"))
assert not format.can_write(Request(lfr_file, "wi"))
assert not format.can_write(Request(lfp_file, "wi"))
assert not format.can_write(Request(raw_f01_file, "wi"))
assert not format.can_write(Request(png_file, "wi"))
def test_reader_and_writer():
# Prepare
filename1 = get_remote_file('images/chelsea.png', test_dir)
filename2 = filename1 + '.out'
F = MyFormat('test', '', modes='i')
# Test using reader
n = 3
R = F.get_reader(Request(filename1, 'ri'))
assert len(R) == n
ims = [im for im in R]
assert len(ims) == n
for i in range(3):
assert ims[i][0, 0] == i
assert ims[i].meta['index'] == i
for i in range(3):
assert R.get_meta_data(i)['index'] == i
# Read next
assert R.get_data(0)[0, 0] == 0
assert R.get_next_data()[0, 0] == 1
assert R.get_next_data()[0, 0] == 2
# Fail
R._failmode = 1
raises(ValueError, R.get_data, 0)
raises(ValueError, R.get_meta_data, 0)
R._failmode = 2
with raises(IndexError):
[im for im in R]
# Test writer no format
raises(ValueError, imageio.get_writer, 'foo.unknownext')
# Test streaming reader
R = F.get_reader(Request(filename1, 'ri'))
R._stream_mode = True
assert R.get_length() == np.inf
ims = [im for im in R]
assert len(ims) == 5
# Test using writer
im1 = np.zeros((10, 10))
im2 = imageio.core.Image(im1, {'foo': 1})
W = F.get_writer(Request(filename2, 'wi'))
W.append_data(im1)
W.append_data(im2)
W.append_data(im1, {'bar': 1})
W.append_data(im2, {'bar': 1})
# Test that no data is copies (but may be different views)
assert len(W._written_data) == 4
for im in W._written_data:
assert (im == im1).all()
im1[2, 2] == 99
for im in W._written_data:
assert (im == im1).all()
# Test meta
assert W._written_meta[0] == {}
assert W._written_meta[1] == {'foo': 1}
assert W._written_meta[2] == {'bar': 1}
assert W._written_meta[3] == {'foo': 1, 'bar': 1}
#
W.set_meta_data({'spam': 1})
assert W._meta == {'spam': 1}
# Fail
raises(ValueError, W.append_data, 'not an array')
raises(ValueError, W.append_data, im, 'not a dict')
raises(ValueError, W.set_meta_data, 'not a dict')
def test_format():
""" Test the working of the Format class """
filename1 = get_remote_file('images/chelsea.png', test_dir)
filename2 = filename1 + '.out'
# Test basic format creation
F = Format('testname', 'test description', 'foo bar spam')
assert F.name == 'TESTNAME'
assert F.description == 'test description'
assert F.name in repr(F)
assert F.name in F.doc
assert str(F) == F.doc
assert set(F.extensions) == set(['.foo', '.bar', '.spam'])
# Test setting extensions
F1 = Format('test', '', 'foo bar spam')
F2 = Format('test', '', 'foo, bar,spam')
F3 = Format('test', '', ['foo', 'bar', 'spam'])
F4 = Format('test', '', '.foo .bar .spam')
for F in (F1, F2, F3, F4):
assert set(F.extensions) == set(['.foo', '.bar', '.spam'])
# Fail
raises(ValueError, Format, 'test', '', 3) # not valid ext
raises(ValueError, Format, 'test', '', '', 3) # not valid mode
raises(ValueError, Format, 'test', '', '', 'x') # not valid mode
# Test subclassing
F = MyFormat('test', '', modes='i')
assert 'TEST DOCS' in F.doc
# Get and check reader and write classes
R = F.get_reader(Request(filename1, 'ri'))
W = F.get_writer(Request(filename2, 'wi'))
assert isinstance(R, MyFormat.Reader)
assert isinstance(W, MyFormat.Writer)
assert R.format is F
assert W.format is F
assert R.request.filename == filename1
assert W.request.filename == filename2
# Fail
raises(RuntimeError, F.get_reader, Request(filename1, 'rI'))
raises(RuntimeError, F.get_writer, Request(filename2, 'wI'))
# Use as context manager
with R:
pass
with W:
pass
# Objects are now closed, cannot be used
assert R.closed
assert W.closed
#
raises(RuntimeError, R.__enter__)
raises(RuntimeError, W.__enter__)
#
raises(RuntimeError, R.get_data, 0)
raises(RuntimeError, W.append_data, np.zeros((10, 10)))
# Test __del__
R = F.get_reader(Request(filename1, 'ri'))
W = F.get_writer(Request(filename2, 'wi'))
ids = id(R), id(W)
F._closed[:] = []
del R
del W
gc.collect() # Invoke __del__
assert set(ids) == set(F._closed)
def test_reader_and_writer():
# Prepare
filename1 = get_remote_file("images/chelsea.png", test_dir)
filename2 = filename1 + ".out"
F = MyFormat("test", "", modes="i")
# Test using reader
n = 3
R = F.get_reader(Request(filename1, "ri"))
assert len(R) == n
ims = [im for im in R]
assert len(ims) == n
for i in range(3):
assert ims[i][0, 0] == i
assert ims[i].meta["index"] == i
for i in range(3):
assert R.get_meta_data(i)["index"] == i
# Read next
assert R.get_data(0)[0, 0] == 0
assert R.get_next_data()[0, 0] == 1
assert R.get_next_data()[0, 0] == 2
# Fail
R._failmode = 1
raises(ValueError, R.get_data, 0)
raises(ValueError, R.get_meta_data, 0)
R._failmode = 2
with raises(IndexError):
[im for im in R]
# Test writer no format
raises(ValueError, imageio.get_writer, "foo.unknownext")
# Test streaming reader
R = F.get_reader(Request(filename1, "ri"))
R._stream_mode = True
assert R.get_length() == np.inf
ims = [im for im in R]
assert len(ims) == 5
# Test using writer
im1 = np.zeros((10, 10))
im2 = imageio.core.Image(im1, {"foo": 1})
W = F.get_writer(Request(filename2, "wi"))
W.append_data(im1)
W.append_data(im2)
W.append_data(im1, {"bar": 1})
W.append_data(im2, {"bar": 1})
# Test that no data is copies (but may be different views)
assert len(W._written_data) == 4
for im in W._written_data:
assert (im == im1).all()
im1[2, 2] == 99
for im in W._written_data:
assert (im == im1).all()
# Test meta
assert W._written_meta[0] == {}
assert W._written_meta[1] == {"foo": 1}
assert W._written_meta[2] == {"bar": 1}
assert W._written_meta[3] == {"foo": 1, "bar": 1}
#
W.set_meta_data({"spam": 1})
assert W._meta == {"spam": 1}
# Fail
raises(ValueError, W.append_data, "not an array")
raises(ValueError, W.append_data, im, "not a dict")
raises(ValueError, W.set_meta_data, "not a dict")
def test_request_read_sources():
# Make an image available in many ways
fname = 'images/chelsea.png'
filename = get_remote_file(fname, test_dir)
bytes = open(filename, 'rb').read()
#
burl = 'https://raw.githubusercontent.com/imageio/imageio-binaries/master/'
z = ZipFile(os.path.join(test_dir, 'test.zip'), 'w')
z.writestr(fname, bytes)
z.close()
file = open(filename, 'rb')
# Read that image from these different sources. Read data from file
# and from local file (the two main plugin-facing functions)
for uri in (filename,
os.path.join(test_dir, 'test.zip', fname),
bytes,
file,
burl + fname):
# Init
firsbytes_list, bytes_list = [], []
# Via file
R = Request(uri, 'ri')
firsbytes_list.append(R.firstbytes)
bytes_list.append(R.get_file().read())
R.finish()
# Via local filename
R = Request(uri, 'ri')
firsbytes_list.append(R.firstbytes)
f = open(R.get_local_filename(), 'rb')
bytes_list.append(f.read())
R.finish()
# Test repeated
if uri == filename:
bytes_list.append(R.get_file().read())
f = open(R.get_local_filename(), 'rb')
bytes_list.append(f.read())
R.finish()
# Test
for i in range(len(firsbytes_list)):
assert len(firsbytes_list[i]) > 0
assert bytes.startswith(firsbytes_list[i])
for i in range(len(bytes_list)):
assert bytes == bytes_list[i]
def test_request():
""" Test request object """
# Check uri-type, this is not a public property, so we test the private
R = Request('http://example.com', 'ri')
assert R._uri_type == core.request.URI_HTTP
R = Request('ftp://example.com', 'ri')
assert R._uri_type == core.request.URI_FTP
R = Request('file://~/foo.png', 'wi')
assert R._uri_type == core.request.URI_FILENAME
R = Request('<video0>', 'rI')
assert R._uri_type == core.request.URI_BYTES
R = Request(imageio.RETURN_BYTES, 'wi')
assert R._uri_type == core.request.URI_BYTES
#
fname = get_remote_file('images/chelsea.png', test_dir)
R = Request(fname, 'ri')
assert R._uri_type == core.request.URI_FILENAME
R = Request('~/filethatdoesnotexist', 'wi')
assert R._uri_type == core.request.URI_FILENAME # Too short to be bytes
R = Request(b'x' * 600, 'ri')
assert R._uri_type == core.request.URI_BYTES
R = Request(sys.stdin, 'ri')
assert R._uri_type == core.request.URI_FILE
R = Request(sys.stdout, 'wi')
assert R._uri_type == core.request.URI_FILE
# exapand user dir
R = Request('~/foo', 'wi')
assert R.filename == os.path.expanduser('~/foo').replace('/', os.path.sep)
# zip file
R = Request('~/bar.zip/spam.png', 'wi')
assert R._uri_type == core.request.URI_ZIPPED
# Test failing inits
raises(ValueError, Request, '/some/file', None) # mode must be str
raises(ValueError, Request, '/some/file', 3) # mode must be str
raises(ValueError, Request, '/some/file', '') # mode must be len 2
raises(ValueError, Request, '/some/file', 'r') # mode must be len 2
raises(ValueError, Request, '/some/file', 'rii') # mode must be len 2
raises(ValueError, Request, '/some/file', 'xi') # mode[0] must be in rw
raises(ValueError, Request, '/some/file', 'rx') # mode[1] must be in iIvV?
#
raises(IOError, Request, ['invalid', 'uri'] * 10, 'ri') # invalid uri
raises(IOError, Request, 4, 'ri') # invalid uri
raises(IOError, Request, '/does/not/exist', 'ri') # reading nonexistent
raises(IOError, Request, '/does/not/exist.zip/spam.png', 'ri') # dito
raises(IOError, Request, 'http://example.com', 'wi') # no writing here
raises(IOError, Request, '/does/not/exist.png', 'wi') # write dir nonexist
# Test auto-download
R = Request('imageio:chelsea.png', 'ri')
assert R.filename == get_remote_file('images/chelsea.png')
#
R = Request('imageio:chelsea.zip/chelsea.png', 'ri')
assert R._filename_zip[0] == get_remote_file('images/chelsea.zip')
assert R.filename == get_remote_file('images/chelsea.zip') + '/chelsea.png'
