def test_different_models_caches(self):
embedder = ImageEmbedder(
model='painters',
layer='penultimate',
server_url='example.com',
)
embedder.clear_cache()
self.assertEqual(len(embedder._embedder._cache._cache_dict), 0)
embedder(self.single_example)
self.assertEqual(len(embedder._embedder._cache._cache_dict), 1)
embedder._embedder._cache.persist_cache()
self.embedder_server = ImageEmbedder(
model='inception-v3',
layer='penultimate',
server_url='example.com',
)
self.assertEqual(len(self.embedder_server._embedder._cache._cache_dict), 0)
self.embedder_server._embedder._cache.persist_cache()
embedder = ImageEmbedder(
model='painters',
layer='penultimate',
server_url='example.com',
)
self.assertEqual(len(embedder._embedder._cache._cache_dict), 1)
embedder.clear_cache()
def test_different_models_caches(self):
embedder = ImageEmbedder(
model='painters',
layer='penultimate',
server_url='example.com',
)
embedder.clear_cache()
self.assertEqual(len(embedder._cache_dict), 0)
embedder(self.single_example)
self.assertEqual(len(embedder._cache_dict), 1)
embedder.persist_cache()
self.embedder = ImageEmbedder(
model='inception-v3',
layer='penultimate',
server_url='example.com',
)
self.assertEqual(len(self.embedder._cache_dict), 0)
self.embedder.persist_cache()
embedder = ImageEmbedder(
model='painters',
layer='penultimate',
server_url='example.com',
)
self.assertEqual(len(embedder._cache_dict), 1)
embedder.clear_cache()
def test_different_models_caches(self):
embedder = ImageEmbedder(model='painters')
embedder.clear_cache()
self.assertEqual(len(embedder._embedder._cache._cache_dict), 0)
embedder(self.single_example)
self.assertEqual(len(embedder._embedder._cache._cache_dict), 1)
embedder._embedder._cache.persist_cache()
self.embedder_server = ImageEmbedder(model='inception-v3')
self.assertEqual(
len(self.embedder_server._embedder._cache._cache_dict), 0)
self.embedder_server._embedder._cache.persist_cache()
embedder = ImageEmbedder(model='painters')
self.assertEqual(len(embedder._embedder._cache._cache_dict), 1)
embedder.clear_cache()
class ImageEmbedderTest(unittest.TestCase):
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def setUp(self):
logging.disable(logging.CRITICAL)
self.embedder = ImageEmbedder(
model='inception-v3',
layer='penultimate',
server_url='example.com',
)
self.embedder.clear_cache()
self.single_example = [_EXAMPLE_IMAGE_JPG]
def tearDown(self):
self.embedder.clear_cache()
logging.disable(logging.NOTSET)
@patch(_TESTED_MODULE.format('HTTP20Connection'))
def test_connected_to_server(self, ConnectionMock):
ConnectionMock._discover_server.assert_not_called()
self.assertEqual(self.embedder.is_connected_to_server(), True)
# server closes the connection
self.embedder._server_connection.close()
self.assertEqual(self.embedder.is_connected_to_server(), False)
@patch(_TESTED_MODULE.format('HTTP20Connection'))
def test_connection_errors(self, ConnectionMock):
res = self.embedder(self.single_example)
assert_array_equal(res, np.array([np.array([0, 1], dtype=np.float16)]))
self.embedder.clear_cache()
self.embedder._server_connection.close()
ConnectionMock.side_effect = ConnectionRefusedError
with self.assertRaises(ConnectionError):
self.embedder(self.single_example)
ConnectionMock.side_effect = BrokenPipeError
with self.assertRaises(ConnectionError):
self.embedder(self.single_example)
@patch.object(DummyHttp2Connection, 'get_response')
def test_on_stream_reset_by_server(self, ConnectionMock):
ConnectionMock.side_effect = StreamResetError
self.assertEqual(self.embedder(self.single_example), [None])
self.assertEqual(len(self.embedder._cache_dict), 0)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_disconnect_reconnect(self):
self.assertEqual(self.embedder.is_connected_to_server(), True)
self.embedder.disconnect_from_server()
self.assertEqual(self.embedder.is_connected_to_server(), False)
self.embedder.reconnect_to_server()
self.assertEqual(self.embedder.is_connected_to_server(), True)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_auto_reconnect(self):
self.assertEqual(self.embedder.is_connected_to_server(), True)
self.embedder.disconnect_from_server()
self.assertEqual(self.embedder.is_connected_to_server(), False)
self.embedder(self.single_example)
self.assertEqual(self.embedder.is_connected_to_server(), True)
@patch(_TESTED_MODULE.format('HTTP20Connection'))
def test_with_non_existing_image(self, ConnectionMock):
self.single_example = ['/non_existing_image']
self.assertEqual(self.embedder(self.single_example), [None])
ConnectionMock.request.assert_not_called()
ConnectionMock.get_response.assert_not_called()
self.assertEqual(self.embedder._cache_dict, {})
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_on_successful_response(self):
res = self.embedder(self.single_example)
assert_array_equal(res, np.array([np.array([0, 1], dtype=np.float16)]))
self.assertEqual(len(self.embedder._cache_dict), 1)
@patch.object(
DummyHttp2Connection, 'get_response',
lambda self, _: BytesIO(b''))
def test_on_non_json_response(self):
self.assertEqual(self.embedder(self.single_example), [None])
self.assertEqual(len(self.embedder._cache_dict), 0)
@patch.object(
DummyHttp2Connection, 'get_response',
lambda self, _: BytesIO(json.dumps({'wrong_key': None}).encode()))
def test_on_json_wrong_key_response(self):
self.assertEqual(self.embedder(self.single_example), [None])
self.assertEqual(len(self.embedder._cache_dict), 0)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_persistent_caching(self):
self.assertEqual(len(self.embedder._cache_dict), 0)
self.embedder(self.single_example)
self.assertEqual(len(self.embedder._cache_dict), 1)
self.embedder.persist_cache()
self.embedder = ImageEmbedder(
model='inception-v3',
layer='penultimate',
server_url='example.com',
)
self.assertEqual(len(self.embedder._cache_dict), 1)
self.embedder.clear_cache()
self.embedder = ImageEmbedder(
model='inception-v3',
layer='penultimate',
server_url='example.com',
)
self.assertEqual(len(self.embedder._cache_dict), 0)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_different_models_caches(self):
embedder = ImageEmbedder(
model='painters',
layer='penultimate',
server_url='example.com',
)
embedder.clear_cache()
self.assertEqual(len(embedder._cache_dict), 0)
embedder(self.single_example)
self.assertEqual(len(embedder._cache_dict), 1)
embedder.persist_cache()
self.embedder = ImageEmbedder(
model='inception-v3',
layer='penultimate',
server_url='example.com',
)
self.assertEqual(len(self.embedder._cache_dict), 0)
self.embedder.persist_cache()
embedder = ImageEmbedder(
model='painters',
layer='penultimate',
server_url='example.com',
)
self.assertEqual(len(embedder._cache_dict), 1)
embedder.clear_cache()
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_with_statement(self):
with self.embedder as embedder:
embedder(self.single_example)
self.assertEqual(self.embedder.is_connected_to_server(), False)
self.embedder = ImageEmbedder(
model='inception-v3',
layer='penultimate',
server_url='example.com',
)
self.assertEqual(len(self.embedder._cache_dict), 1)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_max_concurrent_streams_setting(self):
self.assertEqual(self.embedder._max_concurrent_streams, 128)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_too_many_examples_for_one_batch(self):
too_many_examples = [_EXAMPLE_IMAGE_JPG for _ in range(200)]
true_res = [np.array([0, 1], dtype=np.float16) for _ in range(200)]
true_res = np.array(true_res)
res = self.embedder(too_many_examples)
assert_array_equal(res, true_res)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_successful_result_shape(self):
more_examples = [_EXAMPLE_IMAGE_JPG for _ in range(5)]
res = self.embedder(more_examples)
self.assertEqual(res.shape, (5, 2))
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_invalid_model(self):
with self.assertRaises(ValueError):
self.embedder = ImageEmbedder(
model='invalid_model',
layer='penultimate',
server_url='example.com',
)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_invalid_layer(self):
with self.assertRaises(ValueError):
self.embedder = ImageEmbedder(
model='inception-v3',
layer='first',
server_url='example.com',
)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_with_grayscale_image(self):
res = self.embedder([_EXAMPLE_IMAGE_GRAYSCALE])
assert_array_equal(res, np.array([np.array([0, 1], dtype=np.float16)]))
self.assertEqual(len(self.embedder._cache_dict), 1)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_with_tiff_image(self):
res = self.embedder([_EXAMPLE_IMAGE_TIFF])
assert_array_equal(res, np.array([np.array([0, 1], dtype=np.float16)]))
self.assertEqual(len(self.embedder._cache_dict), 1)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_server_url_env_var(self):
url_value = 'url:1234'
self.assertTrue(self.embedder._server_url != url_value)
environ['ORANGE_EMBEDDING_API_URL'] = url_value
self.embedder = ImageEmbedder(
model='inception-v3',
layer='penultimate',
server_url='example.com',
)
self.assertTrue(self.embedder._server_url == url_value)
del environ['ORANGE_EMBEDDING_API_URL']
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_embedding_cancelled(self):
self.assertFalse(self.embedder.cancelled)
self.embedder.cancelled = True
with self.assertRaises(Exception):
self.embedder(self.single_example)
def test_version(self):
"""
Test if new version of a hyper library is published
When this test start to fails remove temporary fix in http2_client
marked with TODO
"""
import hyper
self.assertEqual(hyper.__version__, "0.7.0")
class ImageEmbedderTest(unittest.TestCase):
def setUp(self):
logging.disable(logging.CRITICAL)
self.embedder_server = ImageEmbedder(model="inception-v3", )
self.embedder_server.clear_cache()
self.embedder_local = ImageEmbedder(model="squeezenet", )
self.embedder_local.clear_cache()
self.single_example = [_EXAMPLE_IMAGE_JPG]
str_var = StringVariable("Image")
str_var.attributes["origin"] = path.dirname(path.abspath(__file__))
self.data_table = Table.from_numpy(
Domain([], [], metas=[str_var]),
np.empty((3, 0)),
np.empty((3, 0)),
metas=np.array([
[_EXAMPLE_IMAGE_JPG],
[_EXAMPLE_IMAGE_TIFF],
[_EXAMPLE_IMAGE_GRAYSCALE],
]),
)
def tearDown(self):
self.embedder_server.clear_cache()
logging.disable(logging.NOTSET)
@patch(HTTPX_POST_METHOD)
def test_with_non_existing_image(self, connection_mock):
single_example = ["/non_existing_image"]
self.assertEqual(self.embedder_server(single_example), [None])
connection_mock.request.assert_not_called()
connection_mock.get_response.assert_not_called()
self.assertEqual(self.embedder_server._embedder._cache._cache_dict, {})
@patch(HTTPX_POST_METHOD, regular_dummy_sr)
def test_on_successful_response(self):
res = self.embedder_server(self.single_example)
assert_array_equal(res, [[0, 1]])
self.assertEqual(
len(self.embedder_server._embedder._cache._cache_dict), 1)
@patch(HTTPX_POST_METHOD, make_dummy_post(b""))
def test_on_empty_response(self):
np.testing.assert_array_equal(
self.embedder_server(self.single_example), [None])
self.assertEqual(
len(self.embedder_server._embedder._cache._cache_dict), 0)
@patch(HTTPX_POST_METHOD, make_dummy_post(b"blabla"))
def test_on_non_json_response(self):
self.assertEqual(self.embedder_server(self.single_example), [None])
self.assertEqual(
len(self.embedder_server._embedder._cache._cache_dict), 0)
@patch(HTTPX_POST_METHOD, make_dummy_post(b'{"wrong-key": [0, 1]}'))
def test_on_json_wrong_key_response(self):
self.assertEqual(self.embedder_server(self.single_example), [None])
self.assertEqual(
len(self.embedder_server._embedder._cache._cache_dict), 0)
@patch(HTTPX_POST_METHOD, regular_dummy_sr)
def test_with_statement(self):
# server embedder
with self.embedder_server as embedder:
np.testing.assert_array_equal(embedder(self.single_example),
[[0, 1]])
# local embedder
with self.embedder_local as embedder:
emb_ = embedder(self.single_example)
self.assertEqual(1, len(emb_))
self.assertEqual(1000, len(emb_[0]))
@patch(HTTPX_POST_METHOD, regular_dummy_sr)
def test_too_many_examples_for_one_batch(self):
too_many_examples = [_EXAMPLE_IMAGE_JPG for _ in range(200)]
true_res = [np.array([0, 1], dtype=np.float16) for _ in range(200)]
true_res = np.array(true_res)
res = self.embedder_server(too_many_examples)
assert_array_equal(res, true_res)
# no need to test it on local embedder since it does not work
# in batches
@patch(HTTPX_POST_METHOD, regular_dummy_sr)
def test_successful_result_shape(self):
# global embedder
more_examples = [_EXAMPLE_IMAGE_JPG for _ in range(5)]
res = np.array(self.embedder_server(more_examples))
self.assertEqual(res.shape, (5, 2))
# local embedder
more_examples = [_EXAMPLE_IMAGE_JPG for _ in range(5)]
res = np.array(self.embedder_local(more_examples))
self.assertEqual(res.shape, (5, 1000))
def test_invalid_model(self):
with self.assertRaises(ValueError):
self.embedder_server = ImageEmbedder(model="invalid_model")
@patch(HTTPX_POST_METHOD, regular_dummy_sr)
def test_with_grayscale_image(self):
# test server embedder
res = self.embedder_server([_EXAMPLE_IMAGE_GRAYSCALE])
assert_array_equal(res, [[0, 1]])
self.assertEqual(
len(self.embedder_server._embedder._cache._cache_dict), 1)
# test local embedder
res = self.embedder_local([_EXAMPLE_IMAGE_GRAYSCALE])
self.assertTupleEqual((1, 1000), np.array(res).shape)
@patch(HTTPX_POST_METHOD, regular_dummy_sr)
def test_with_tiff_image(self):
# test server embedder
res = self.embedder_server([_EXAMPLE_IMAGE_TIFF])
assert_array_equal(res, np.array([np.array([0, 1], dtype=np.float16)]))
# test local embedder
res = self.embedder_local([_EXAMPLE_IMAGE_TIFF])
self.assertTupleEqual((1, 1000), np.array(res).shape)
@patch(HTTPX_POST_METHOD, regular_dummy_sr)
def test_server_url_env_var(self):
url_value = "http://example.com"
self.embedder_server([_EXAMPLE_IMAGE_JPG]) # to init server embedder
self.assertTrue(self.embedder_server._embedder.server_url != url_value)
environ["ORANGE_EMBEDDING_API_URL"] = url_value
self.embedder_server = ImageEmbedder(model="inception-v3")
self.embedder_server([_EXAMPLE_IMAGE_JPG]) # to init server embedder
self.assertTrue(self.embedder_server._embedder.server_url == url_value)
del environ["ORANGE_EMBEDDING_API_URL"]
def test_table_online_data(self):
data = Table("https://datasets.biolab.si/core/bone-healing.xlsx")
emb, skipped, num_skiped = self.embedder_local(data, col="Image")
self.assertIsNone(skipped)
self.assertEqual(0, num_skiped)
self.assertEqual(len(data), len(emb))
self.assertTupleEqual((len(data), 1000), emb.X.shape)
@patch(HTTPX_POST_METHOD, regular_dummy_sr)
def test_table_server_embedder(self):
data = Table("https://datasets.biolab.si/core/bone-healing.xlsx")
emb, skipped, num_skiped = self.embedder_server(data, col="Image")
self.assertIsNone(skipped)
self.assertEqual(0, num_skiped)
self.assertEqual(len(data), len(emb))
self.assertTupleEqual((len(data), 2), emb.X.shape)
def test_table_local_data(self):
emb, skipped, num_skiped = self.embedder_local(self.data_table,
col="Image")
self.assertIsNone(skipped)
self.assertEqual(0, num_skiped)
self.assertEqual(len(self.data_table), len(emb))
self.assertTupleEqual((len(self.data_table), 1000), emb.X.shape)
def test_table_skip(self):
data = self.data_table
data.metas[0, 0] = "tralala"
emb, skipped, num_skiped = self.embedder_local(data, col="Image")
self.assertIsNotNone(skipped)
self.assertEqual(1, num_skiped)
self.assertEqual(len(data) - 1, len(emb))
self.assertTupleEqual((len(data) - 1, 1000), emb.X.shape)
def test_table_missing_data_beginning(self):
"""
Test with data that have missing data
"""
data = self.data_table
data.metas[0, 0] = data.domain.metas[0].Unknown
emb, skipped, num_skiped = self.embedder_local(data, col="Image")
self.assertIsNotNone(skipped)
self.assertEqual(1, num_skiped)
self.assertEqual(len(data) - 1, len(emb))
self.assertTupleEqual((len(data) - 1, 1000), emb.X.shape)
def test_table_missing_data_middle(self):
"""
Test with data that have missing data
"""
data = self.data_table
data.metas[1, 0] = data.domain.metas[0].Unknown
emb, skipped, num_skiped = self.embedder_local(data, col="Image")
self.assertIsNotNone(skipped)
self.assertEqual(1, num_skiped)
self.assertEqual(len(data) - 1, len(emb))
self.assertTupleEqual((len(data) - 1, 1000), emb.X.shape)
@patch(HTTPX_POST_METHOD, make_dummy_post(b'{"embedding": [0, 1]}',
sleep=1))
def test_wait(self):
"""
Testing if __wait_until_released works correctly
"""
too_many_examples = [_EXAMPLE_IMAGE_JPG for _ in range(200)]
true_res = [np.array([0, 1], dtype=np.float16) for _ in range(200)]
true_res = np.array(true_res)
res = self.embedder_server(too_many_examples)
assert_array_equal(res, true_res)
def test_bad_arguments(self):
"""
Wrong arguments should raise TypeError
"""
with self.assertRaises(AssertionError):
self.embedder_server("abc")
@patch(HTTPX_POST_METHOD, side_effect=OSError)
def test_connection_error(self, _):
for num_images in range(1, 20):
with self.assertRaises(ConnectionError):
self.embedder_server(self.single_example * num_images)
self.setUp() # to init new embedder
@patch(HTTPX_POST_METHOD, make_dummy_post(b'{"embedding": []}', sleep=1))
def test_embedder_empty_response(self):
"""
When embedder cannot embedd an image it will return an empty array
as a response.
"""
more_examples = [_EXAMPLE_IMAGE_JPG for _ in range(5)]
res = self.embedder_server(more_examples)
self.assertListEqual([[]] * 5, res)
emb, skip, num_skip = self.embedder_server(self.data_table,
col="Image")
self.assertIsNone(emb)
self.assertEqual(len(self.data_table), len(skip))
self.assertEqual(len(self.data_table), num_skip)
class ImageEmbedderTest(unittest.TestCase):
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def setUp(self):
self.embedder = ImageEmbedder(
model='inception-v3',
layer='penultimate',
server_url='example.com',
server_port=80
)
self.embedder.clear_cache()
self.single_example = [_EXAMPLE_IMAGE_0]
def tearDown(self):
self.embedder.clear_cache()
@patch(_TESTED_MODULE.format('HTTP20Connection'))
def test_connected_to_server(self, ConnectionMock):
ConnectionMock._discover_server.assert_not_called()
self.assertEqual(self.embedder.is_connected_to_server(), True)
# server closes the connection
self.embedder._server_connection.close()
self.assertEqual(self.embedder.is_connected_to_server(), False)
@patch(_TESTED_MODULE.format('HTTP20Connection'))
def test_connection_errors(self, ConnectionMock):
res = self.embedder(self.single_example)
assert_array_equal(res, np.array([np.array([0, 1], dtype=np.float16)]))
self.embedder.clear_cache()
self.embedder._server_connection.close()
ConnectionMock.side_effect = ConnectionRefusedError
with self.assertRaises(ConnectionError):
self.embedder(self.single_example)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_disconnect_reconnect(self):
self.assertEqual(self.embedder.is_connected_to_server(), True)
self.embedder.disconnect_from_server()
self.assertEqual(self.embedder.is_connected_to_server(), False)
self.embedder.reconnect_to_server()
self.assertEqual(self.embedder.is_connected_to_server(), True)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_auto_reconnect(self):
self.assertEqual(self.embedder.is_connected_to_server(), True)
self.embedder.disconnect_from_server()
self.assertEqual(self.embedder.is_connected_to_server(), False)
self.embedder(self.single_example)
self.assertEqual(self.embedder.is_connected_to_server(), True)
@patch(_TESTED_MODULE.format('HTTP20Connection'))
def test_with_non_existing_image(self, ConnectionMock):
self.single_example = ['/non_existing_image']
self.assertEqual(self.embedder(self.single_example), [None])
ConnectionMock.request.assert_not_called()
ConnectionMock.get_response.assert_not_called()
self.assertEqual(self.embedder._cache_dict, {})
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_on_successful_response(self):
res = self.embedder(self.single_example)
assert_array_equal(res, np.array([np.array([0, 1], dtype=np.float16)]))
self.assertEqual(len(self.embedder._cache_dict), 1)
@patch.object(
DummyHttp2Connection, 'get_response',
lambda self, _: BytesIO(b''))
def test_on_non_json_response(self):
self.assertEqual(self.embedder(self.single_example), [None])
self.assertEqual(len(self.embedder._cache_dict), 0)
@patch.object(
DummyHttp2Connection, 'get_response',
lambda self, _: BytesIO(json.dumps({'wrong_key': None}).encode()))
def test_on_json_wrong_key_response(self):
self.assertEqual(self.embedder(self.single_example), [None])
self.assertEqual(len(self.embedder._cache_dict), 0)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_persistent_caching(self):
self.assertEqual(len(self.embedder._cache_dict), 0)
self.embedder(self.single_example)
self.assertEqual(len(self.embedder._cache_dict), 1)
self.embedder.persist_cache()
self.embedder = ImageEmbedder(
model='inception-v3',
layer='penultimate',
server_url='example.com',
server_port=80
)
self.assertEqual(len(self.embedder._cache_dict), 1)
self.embedder.clear_cache()
self.embedder = ImageEmbedder(
model='inception-v3',
layer='penultimate',
server_url='example.com',
server_port=80
)
self.assertEqual(len(self.embedder._cache_dict), 0)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_with_statement(self):
with self.embedder as embedder:
embedder(self.single_example)
self.assertEqual(self.embedder.is_connected_to_server(), False)
self.embedder = ImageEmbedder(
model='inception-v3',
layer='penultimate',
server_url='example.com',
server_port=80
)
self.assertEqual(len(self.embedder._cache_dict), 1)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_max_concurrent_streams_setting(self):
self.assertEqual(self.embedder._max_concurrent_streams, 128)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_too_many_examples_for_one_batch(self):
too_many_examples = [_EXAMPLE_IMAGE_0 for _ in range(200)]
true_res = [np.array([0, 1], dtype=np.float16) for _ in range(200)]
true_res = np.array(true_res)
res = self.embedder(too_many_examples)
assert_array_equal(res, true_res)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_successful_result_shape(self):
more_examples = [_EXAMPLE_IMAGE_0 for _ in range(5)]
res = self.embedder(more_examples)
self.assertEqual(res.shape, (5, 2))
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_invalid_model(self):
with self.assertRaises(ValueError):
self.embedder = ImageEmbedder(
model='invalid_model',
layer='penultimate',
server_url='example.com',
server_port=80
)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_invalid_layer(self):
with self.assertRaises(ValueError):
self.embedder = ImageEmbedder(
model='inception-v3',
layer='first',
server_url='example.com',
server_port=80
)
class ImageEmbedderTest(unittest.TestCase):
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def setUp(self):
logging.disable(logging.CRITICAL)
self.embedder_server = ImageEmbedder(
model='inception-v3',
layer='penultimate',
server_url='example.com',
)
self.embedder_server.clear_cache()
self.embedder_local = ImageEmbedder(
model='squeezenet',
layer='penultimate',
server_url='example.com',
)
self.embedder_local.clear_cache()
self.single_example = [_EXAMPLE_IMAGE_JPG]
def tearDown(self):
self.embedder_server.clear_cache()
logging.disable(logging.NOTSET)
@patch(_TESTED_MODULE.format('HTTP20Connection'))
def test_connected_to_server(self, ConnectionMock):
ConnectionMock._discover_server.assert_not_called()
self.assertEqual(self.embedder_server.is_connected_to_server(), True)
# server closes the connection
self.embedder_server._embedder._server_connection.close()
self.assertEqual(self.embedder_server.is_connected_to_server(), False)
@patch(_TESTED_MODULE.format('HTTP20Connection'))
def test_connection_errors(self, ConnectionMock):
res = self.embedder_server(self.single_example)
assert_array_equal(res, np.array([np.array([0, 1], dtype=np.float16)]))
self.embedder_server.clear_cache()
self.embedder_server._embedder._server_connection.close()
ConnectionMock.side_effect = ConnectionRefusedError
with self.assertRaises(ConnectionError):
self.embedder_server(self.single_example)
ConnectionMock.side_effect = BrokenPipeError
with self.assertRaises(ConnectionError):
self.embedder_server(self.single_example)
@patch.object(DummyHttp2Connection, 'get_response')
def test_on_stream_reset_by_server(self, ConnectionMock):
ConnectionMock.side_effect = StreamResetError
self.assertEqual(self.embedder_server(self.single_example), [None])
self.assertEqual(len(self.embedder_server._embedder._cache._cache_dict), 0)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_disconnect_reconnect(self):
self.assertEqual(self.embedder_server.is_connected_to_server(), True)
self.embedder_server._embedder.disconnect_from_server()
self.assertEqual(self.embedder_server.is_connected_to_server(), False)
self.embedder_server.reconnect_to_server()
self.assertEqual(self.embedder_server.is_connected_to_server(), True)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_auto_reconnect(self):
self.assertEqual(self.embedder_server.is_connected_to_server(), True)
self.embedder_server._embedder.disconnect_from_server()
self.assertEqual(self.embedder_server.is_connected_to_server(), False)
self.embedder_server(self.single_example)
self.assertEqual(self.embedder_server.is_connected_to_server(), True)
@patch(_TESTED_MODULE.format('HTTP20Connection'))
def test_with_non_existing_image(self, ConnectionMock):
self.single_example = ['/non_existing_image']
self.assertEqual(self.embedder_server(self.single_example), [None])
ConnectionMock.request.assert_not_called()
ConnectionMock.get_response.assert_not_called()
self.assertEqual(self.embedder_server._embedder._cache._cache_dict, {})
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_on_successful_response(self):
res = self.embedder_server(self.single_example)
assert_array_equal(res, np.array([np.array([0, 1], dtype=np.float16)]))
self.assertEqual(len(self.embedder_server._embedder._cache._cache_dict), 1)
@patch.object(
DummyHttp2Connection, 'get_response',
lambda self, _: BytesIO(b''))
def test_on_non_json_response(self):
self.assertEqual(self.embedder_server(self.single_example), [None])
self.assertEqual(len(self.embedder_server._embedder._cache._cache_dict), 0)
@patch.object(
DummyHttp2Connection, 'get_response',
lambda self, _: BytesIO(json.dumps({'wrong_key': None}).encode()))
def test_on_json_wrong_key_response(self):
self.assertEqual(self.embedder_server(self.single_example), [None])
self.assertEqual(len(self.embedder_server._embedder._cache._cache_dict), 0)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_persistent_caching(self):
self.assertEqual(len(self.embedder_server._embedder._cache._cache_dict), 0)
self.embedder_server(self.single_example)
self.assertEqual(len(self.embedder_server._embedder._cache._cache_dict), 1)
self.embedder_server._embedder._cache.persist_cache()
self.embedder_server = ImageEmbedder(
model='inception-v3',
layer='penultimate',
server_url='example.com',
)
self.assertEqual(len(self.embedder_server._embedder._cache._cache_dict), 1)
self.embedder_server.clear_cache()
self.embedder_server = ImageEmbedder(
model='inception-v3',
layer='penultimate',
server_url='example.com',
)
self.assertEqual(len(self.embedder_server._embedder._cache._cache_dict), 0)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_different_models_caches(self):
embedder = ImageEmbedder(
model='painters',
layer='penultimate',
server_url='example.com',
)
embedder.clear_cache()
self.assertEqual(len(embedder._embedder._cache._cache_dict), 0)
embedder(self.single_example)
self.assertEqual(len(embedder._embedder._cache._cache_dict), 1)
embedder._embedder._cache.persist_cache()
self.embedder_server = ImageEmbedder(
model='inception-v3',
layer='penultimate',
server_url='example.com',
)
self.assertEqual(len(self.embedder_server._embedder._cache._cache_dict), 0)
self.embedder_server._embedder._cache.persist_cache()
embedder = ImageEmbedder(
model='painters',
layer='penultimate',
server_url='example.com',
)
self.assertEqual(len(embedder._embedder._cache._cache_dict), 1)
embedder.clear_cache()
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_with_statement(self):
# server embedder
with self.embedder_server as embedder:
embedder(self.single_example)
self.assertEqual(self.embedder_server.is_connected_to_server(), False)
self.embedder_server = ImageEmbedder(
model='inception-v3',
layer='penultimate',
server_url='example.com',
)
self.assertEqual(
len(self.embedder_server._embedder._cache._cache_dict), 1)
# local embedder
with self.embedder_local as embedder:
embedder(self.single_example)
self.assertEqual(self.embedder_local.is_connected_to_server(), False)
self.embedder_local = ImageEmbedder(
model='squeezenet',
layer='penultimate',
server_url='example.com',
)
self.assertEqual(
len(self.embedder_local._embedder._cache._cache_dict), 1)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_max_concurrent_streams_setting(self):
self.assertEqual(self.embedder_server._embedder._max_concurrent_streams, 128)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_too_many_examples_for_one_batch(self):
too_many_examples = [_EXAMPLE_IMAGE_JPG for _ in range(200)]
true_res = [np.array([0, 1], dtype=np.float16) for _ in range(200)]
true_res = np.array(true_res)
res = self.embedder_server(too_many_examples)
assert_array_equal(res, true_res)
# no need to test it on local embedder since it does not work
# in batches
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_successful_result_shape(self):
# global embedder
more_examples = [_EXAMPLE_IMAGE_JPG for _ in range(5)]
res = self.embedder_server(more_examples)
self.assertEqual(res.shape, (5, 2))
# local embedder
more_examples = [_EXAMPLE_IMAGE_JPG for _ in range(5)]
res = self.embedder_local(more_examples)
self.assertEqual(res.shape, (5, 1000))
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_invalid_model(self):
with self.assertRaises(ValueError):
self.embedder_server = ImageEmbedder(
model='invalid_model',
layer='penultimate',
server_url='example.com',
)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_invalid_layer(self):
# test server embedder
with self.assertRaises(ValueError):
self.embedder_server = ImageEmbedder(
model='inception-v3',
layer='first',
server_url='example.com',
)
# test local embedder
with self.assertRaises(ValueError):
self.embedder_server = ImageEmbedder(
model='squeezenet',
layer='first',
server_url='example.com',
)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_with_grayscale_image(self):
# test server embedder
res = self.embedder_server([_EXAMPLE_IMAGE_GRAYSCALE])
assert_array_equal(res, np.array([np.array([0, 1], dtype=np.float16)]))
self.assertEqual(len(self.embedder_server._embedder._cache._cache_dict), 1)
# test local embedder
res = self.embedder_local([_EXAMPLE_IMAGE_GRAYSCALE])
self.assertEqual(
len(self.embedder_local._embedder._cache._cache_dict), 1)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_with_tiff_image(self):
# test server embedder
res = self.embedder_server([_EXAMPLE_IMAGE_TIFF])
assert_array_equal(res, np.array([np.array([0, 1], dtype=np.float16)]))
self.assertEqual(
len(self.embedder_server._embedder._cache._cache_dict), 1)
# test local embedder
res = self.embedder_local([_EXAMPLE_IMAGE_TIFF])
self.assertEqual(
len(self.embedder_local._embedder._cache._cache_dict), 1)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_server_url_env_var(self):
url_value = 'url:1234'
self.assertTrue(self.embedder_server._embedder._server_url != url_value)
environ['ORANGE_EMBEDDING_API_URL'] = url_value
self.embedder_server = ImageEmbedder(
model='inception-v3',
layer='penultimate',
server_url='example.com',
)
self.assertTrue(self.embedder_server._embedder._server_url == url_value)
del environ['ORANGE_EMBEDDING_API_URL']
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_embedding_cancelled(self):
# test for the server embedders
self.assertFalse(self.embedder_server._embedder.cancelled)
self.embedder_server._embedder.cancelled = True
with self.assertRaises(Exception):
self.embedder_server(self.single_example)
# test for the local embedder
self.assertFalse(self.embedder_local._embedder.cancelled)
self.embedder_local._embedder.cancelled = True
with self.assertRaises(Exception):
self.embedder_local(self.single_example)
def test_table_online_data(self):
data = Table("https://datasets.biolab.si/core/bone-healing.xlsx")
emb, skipped, num_skiped = self.embedder_local(data, col="Image")
self.assertIsNone(skipped)
self.assertEqual(0, num_skiped)
self.assertEqual(len(data), len(emb))
self.assertTupleEqual((len(data), 1000), emb.X.shape)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_table_server_embedder(self):
data = Table("https://datasets.biolab.si/core/bone-healing.xlsx")
emb, skipped, num_skiped = self.embedder_server(data, col="Image")
self.assertIsNone(skipped)
self.assertEqual(0, num_skiped)
self.assertEqual(len(data), len(emb))
self.assertTupleEqual((len(data), 2), emb.X.shape)
def test_table_local_data(self):
str_var = StringVariable("Image")
str_var.attributes["origin"] = path.dirname(
path.abspath(__file__))
data = Table(
Domain([], [], metas=[str_var]),
np.empty((3, 0)), np.empty((3, 0)),
metas=[[_EXAMPLE_IMAGE_JPG],
[_EXAMPLE_IMAGE_TIFF],
[_EXAMPLE_IMAGE_GRAYSCALE]])
emb, skipped, num_skiped = self.embedder_local(data, col="Image")
self.assertIsNone(skipped)
self.assertEqual(0, num_skiped)
self.assertEqual(len(data), len(emb))
self.assertTupleEqual((len(data), 1000), emb.X.shape)
def test_table_skip(self):
data = Table("https://datasets.biolab.si/core/bone-healing.xlsx")
data.metas[0, 1] = "tralala"
emb, skipped, num_skiped = self.embedder_local(data, col="Image")
self.assertIsNotNone(skipped)
self.assertEqual(1, num_skiped)
self.assertEqual(len(data) - 1, len(emb))
self.assertTupleEqual((len(data) - 1, 1000), emb.X.shape)
class ImageEmbedderTest(unittest.TestCase):
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def setUp(self):
logging.disable(logging.CRITICAL)
self.embedder = ImageEmbedder(model='inception-v3',
layer='penultimate',
server_url='example.com',
server_port=80)
self.embedder.clear_cache()
self.single_example = [_EXAMPLE_IMAGE_JPG]
def tearDown(self):
self.embedder.clear_cache()
logging.disable(logging.NOTSET)
@patch(_TESTED_MODULE.format('HTTP20Connection'))
def test_connected_to_server(self, ConnectionMock):
ConnectionMock._discover_server.assert_not_called()
self.assertEqual(self.embedder.is_connected_to_server(), True)
# server closes the connection
self.embedder._server_connection.close()
self.assertEqual(self.embedder.is_connected_to_server(), False)
@patch(_TESTED_MODULE.format('HTTP20Connection'))
def test_connection_errors(self, ConnectionMock):
res = self.embedder(self.single_example)
assert_array_equal(res, np.array([np.array([0, 1], dtype=np.float16)]))
self.embedder.clear_cache()
self.embedder._server_connection.close()
ConnectionMock.side_effect = ConnectionRefusedError
with self.assertRaises(ConnectionError):
self.embedder(self.single_example)
@patch.object(DummyHttp2Connection, 'get_response')
def test_on_stream_reset_by_server(self, ConnectionMock):
ConnectionMock.side_effect = StreamResetError
self.assertEqual(self.embedder(self.single_example), [None])
self.assertEqual(len(self.embedder._cache_dict), 0)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_disconnect_reconnect(self):
self.assertEqual(self.embedder.is_connected_to_server(), True)
self.embedder.disconnect_from_server()
self.assertEqual(self.embedder.is_connected_to_server(), False)
self.embedder.reconnect_to_server()
self.assertEqual(self.embedder.is_connected_to_server(), True)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_auto_reconnect(self):
self.assertEqual(self.embedder.is_connected_to_server(), True)
self.embedder.disconnect_from_server()
self.assertEqual(self.embedder.is_connected_to_server(), False)
self.embedder(self.single_example)
self.assertEqual(self.embedder.is_connected_to_server(), True)
@patch(_TESTED_MODULE.format('HTTP20Connection'))
def test_with_non_existing_image(self, ConnectionMock):
self.single_example = ['/non_existing_image']
self.assertEqual(self.embedder(self.single_example), [None])
ConnectionMock.request.assert_not_called()
ConnectionMock.get_response.assert_not_called()
self.assertEqual(self.embedder._cache_dict, {})
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_on_successful_response(self):
res = self.embedder(self.single_example)
assert_array_equal(res, np.array([np.array([0, 1], dtype=np.float16)]))
self.assertEqual(len(self.embedder._cache_dict), 1)
@patch.object(DummyHttp2Connection, 'get_response',
lambda self, _: BytesIO(b''))
def test_on_non_json_response(self):
self.assertEqual(self.embedder(self.single_example), [None])
self.assertEqual(len(self.embedder._cache_dict), 0)
@patch.object(
DummyHttp2Connection, 'get_response',
lambda self, _: BytesIO(json.dumps({
'wrong_key': None
}).encode()))
def test_on_json_wrong_key_response(self):
self.assertEqual(self.embedder(self.single_example), [None])
self.assertEqual(len(self.embedder._cache_dict), 0)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_persistent_caching(self):
self.assertEqual(len(self.embedder._cache_dict), 0)
self.embedder(self.single_example)
self.assertEqual(len(self.embedder._cache_dict), 1)
self.embedder.persist_cache()
self.embedder = ImageEmbedder(model='inception-v3',
layer='penultimate',
server_url='example.com',
server_port=80)
self.assertEqual(len(self.embedder._cache_dict), 1)
self.embedder.clear_cache()
self.embedder = ImageEmbedder(model='inception-v3',
layer='penultimate',
server_url='example.com',
server_port=80)
self.assertEqual(len(self.embedder._cache_dict), 0)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_with_statement(self):
with self.embedder as embedder:
embedder(self.single_example)
self.assertEqual(self.embedder.is_connected_to_server(), False)
self.embedder = ImageEmbedder(model='inception-v3',
layer='penultimate',
server_url='example.com',
server_port=80)
self.assertEqual(len(self.embedder._cache_dict), 1)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_max_concurrent_streams_setting(self):
self.assertEqual(self.embedder._max_concurrent_streams, 128)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_too_many_examples_for_one_batch(self):
too_many_examples = [_EXAMPLE_IMAGE_JPG for _ in range(200)]
true_res = [np.array([0, 1], dtype=np.float16) for _ in range(200)]
true_res = np.array(true_res)
res = self.embedder(too_many_examples)
assert_array_equal(res, true_res)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_successful_result_shape(self):
more_examples = [_EXAMPLE_IMAGE_JPG for _ in range(5)]
res = self.embedder(more_examples)
self.assertEqual(res.shape, (5, 2))
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_invalid_model(self):
with self.assertRaises(ValueError):
self.embedder = ImageEmbedder(model='invalid_model',
layer='penultimate',
server_url='example.com',
server_port=80)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_invalid_layer(self):
with self.assertRaises(ValueError):
self.embedder = ImageEmbedder(model='inception-v3',
layer='first',
server_url='example.com',
server_port=80)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_with_grayscale_image(self):
res = self.embedder([_EXAMPLE_IMAGE_GRAYSCALE])
assert_array_equal(res, np.array([np.array([0, 1], dtype=np.float16)]))
self.assertEqual(len(self.embedder._cache_dict), 1)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_with_tiff_image(self):
res = self.embedder([_EXAMPLE_IMAGE_TIFF])
assert_array_equal(res, np.array([np.array([0, 1], dtype=np.float16)]))
self.assertEqual(len(self.embedder._cache_dict), 1)
class ImageEmbedderTest(unittest.TestCase):
def setUp(self):
logging.disable(logging.CRITICAL)
self.embedder_server = ImageEmbedder(model='inception-v3', )
self.embedder_server.clear_cache()
self.embedder_local = ImageEmbedder(model='squeezenet', )
self.embedder_local.clear_cache()
self.single_example = [_EXAMPLE_IMAGE_JPG]
def tearDown(self):
self.embedder_server.clear_cache()
logging.disable(logging.NOTSET)
@patch(HTTPX_POST_METHOD)
def test_with_non_existing_image(self, connection_mock):
single_example = ['/non_existing_image']
self.assertEqual(self.embedder_server(single_example), [None])
connection_mock.request.assert_not_called()
connection_mock.get_response.assert_not_called()
self.assertEqual(self.embedder_server._embedder._cache._cache_dict, {})
@patch(HTTPX_POST_METHOD, regular_dummy_sr)
def test_on_successful_response(self):
res = self.embedder_server(self.single_example)
assert_array_equal(res, [[0, 1]])
self.assertEqual(
len(self.embedder_server._embedder._cache._cache_dict), 1)
@patch(HTTPX_POST_METHOD, make_dummy_post(b''))
def test_on_empty_response(self):
self.assertEqual(self.embedder_server(self.single_example), [None])
self.assertEqual(
len(self.embedder_server._embedder._cache._cache_dict), 0)
@patch(HTTPX_POST_METHOD, make_dummy_post(b'blabla'))
def test_on_non_json_response(self):
self.assertEqual(self.embedder_server(self.single_example), [None])
self.assertEqual(
len(self.embedder_server._embedder._cache._cache_dict), 0)
@patch(HTTPX_POST_METHOD, make_dummy_post(b'{"wrong-key": [0, 1]}'))
def test_on_json_wrong_key_response(self):
self.assertEqual(self.embedder_server(self.single_example), [None])
self.assertEqual(
len(self.embedder_server._embedder._cache._cache_dict), 0)
@patch(HTTPX_POST_METHOD, regular_dummy_sr)
def test_persistent_caching(self):
self.assertEqual(
len(self.embedder_server._embedder._cache._cache_dict), 0)
self.embedder_server(self.single_example)
self.assertEqual(
len(self.embedder_server._embedder._cache._cache_dict), 1)
self.embedder_server._embedder._cache.persist_cache()
self.embedder_server = ImageEmbedder(model='inception-v3')
self.assertEqual(
len(self.embedder_server._embedder._cache._cache_dict), 1)
self.embedder_server.clear_cache()
self.embedder_server = ImageEmbedder(model='inception-v3')
self.assertEqual(
len(self.embedder_server._embedder._cache._cache_dict), 0)
@patch(HTTPX_POST_METHOD, regular_dummy_sr)
def test_different_models_caches(self):
embedder = ImageEmbedder(model='painters')
embedder.clear_cache()
self.assertEqual(len(embedder._embedder._cache._cache_dict), 0)
embedder(self.single_example)
self.assertEqual(len(embedder._embedder._cache._cache_dict), 1)
embedder._embedder._cache.persist_cache()
self.embedder_server = ImageEmbedder(model='inception-v3')
self.assertEqual(
len(self.embedder_server._embedder._cache._cache_dict), 0)
self.embedder_server._embedder._cache.persist_cache()
embedder = ImageEmbedder(model='painters')
self.assertEqual(len(embedder._embedder._cache._cache_dict), 1)
embedder.clear_cache()
@patch(HTTPX_POST_METHOD, regular_dummy_sr)
def test_with_statement(self):
# server embedder
with self.embedder_server as embedder:
np.testing.assert_array_equal(embedder(self.single_example),
[[0, 1]])
self.embedder_server = ImageEmbedder(model='inception-v3')
self.assertEqual(
len(self.embedder_server._embedder._cache._cache_dict), 1)
# local embedder
with self.embedder_local as embedder:
self.assertTupleEqual((1, 1000),
embedder(self.single_example).shape)
self.embedder_local = ImageEmbedder(model='squeezenet')
self.assertEqual(len(self.embedder_local._embedder._cache._cache_dict),
1)
@patch(HTTPX_POST_METHOD, regular_dummy_sr)
def test_too_many_examples_for_one_batch(self):
too_many_examples = [_EXAMPLE_IMAGE_JPG for _ in range(200)]
true_res = [np.array([0, 1], dtype=np.float16) for _ in range(200)]
true_res = np.array(true_res)
res = self.embedder_server(too_many_examples)
assert_array_equal(res, true_res)
# no need to test it on local embedder since it does not work
# in batches
@patch(HTTPX_POST_METHOD, regular_dummy_sr)
def test_successful_result_shape(self):
# global embedder
more_examples = [_EXAMPLE_IMAGE_JPG for _ in range(5)]
res = np.array(self.embedder_server(more_examples))
self.assertEqual(res.shape, (5, 2))
# local embedder
more_examples = [_EXAMPLE_IMAGE_JPG for _ in range(5)]
res = np.array(self.embedder_local(more_examples))
self.assertEqual(res.shape, (5, 1000))
def test_invalid_model(self):
with self.assertRaises(ValueError):
self.embedder_server = ImageEmbedder(model='invalid_model')
@patch(HTTPX_POST_METHOD, regular_dummy_sr)
def test_with_grayscale_image(self):
# test server embedder
res = self.embedder_server([_EXAMPLE_IMAGE_GRAYSCALE])
assert_array_equal(res, [[0, 1]])
self.assertEqual(
len(self.embedder_server._embedder._cache._cache_dict), 1)
# test local embedder
res = self.embedder_local([_EXAMPLE_IMAGE_GRAYSCALE])
self.assertTupleEqual((1, 1000), np.array(res).shape)
self.assertEqual(len(self.embedder_local._embedder._cache._cache_dict),
1)
@patch(HTTPX_POST_METHOD, regular_dummy_sr)
def test_with_tiff_image(self):
# test server embedder
res = self.embedder_server([_EXAMPLE_IMAGE_TIFF])
assert_array_equal(res, np.array([np.array([0, 1], dtype=np.float16)]))
self.assertEqual(
len(self.embedder_server._embedder._cache._cache_dict), 1)
# test local embedder
res = self.embedder_local([_EXAMPLE_IMAGE_TIFF])
self.assertTupleEqual((1, 1000), np.array(res).shape)
self.assertEqual(len(self.embedder_local._embedder._cache._cache_dict),
1)
@patch(HTTPX_POST_METHOD, regular_dummy_sr)
def test_server_url_env_var(self):
url_value = 'url:1234'
self.assertTrue(self.embedder_server._embedder.server_url != url_value)
environ['ORANGE_EMBEDDING_API_URL'] = url_value
self.embedder_server = ImageEmbedder(model='inception-v3', )
self.assertTrue(self.embedder_server._embedder.server_url == url_value)
del environ['ORANGE_EMBEDDING_API_URL']
@patch(HTTPX_POST_METHOD, regular_dummy_sr)
def test_embedding_cancelled(self):
# test for the server embedders
self.assertFalse(self.embedder_server._embedder.cancelled)
self.embedder_server._embedder.cancelled = True
with self.assertRaises(Exception):
self.embedder_server(self.single_example)
# test for the local embedder
self.assertFalse(self.embedder_local._embedder.cancelled)
self.embedder_local._embedder.cancelled = True
with self.assertRaises(Exception):
self.embedder_local(self.single_example)
def test_table_online_data(self):
data = Table("https://datasets.biolab.si/core/bone-healing.xlsx")
emb, skipped, num_skiped = self.embedder_local(data, col="Image")
self.assertIsNone(skipped)
self.assertEqual(0, num_skiped)
self.assertEqual(len(data), len(emb))
self.assertTupleEqual((len(data), 1000), emb.X.shape)
@patch(HTTPX_POST_METHOD, regular_dummy_sr)
def test_table_server_embedder(self):
data = Table("https://datasets.biolab.si/core/bone-healing.xlsx")
emb, skipped, num_skiped = self.embedder_server(data, col="Image")
self.assertIsNone(skipped)
self.assertEqual(0, num_skiped)
self.assertEqual(len(data), len(emb))
self.assertTupleEqual((len(data), 2), emb.X.shape)
def test_table_local_data(self):
str_var = StringVariable("Image")
str_var.attributes["origin"] = path.dirname(path.abspath(__file__))
data = Table(Domain([], [], metas=[str_var]),
np.empty((3, 0)),
np.empty((3, 0)),
metas=[[_EXAMPLE_IMAGE_JPG], [_EXAMPLE_IMAGE_TIFF],
[_EXAMPLE_IMAGE_GRAYSCALE]])
emb, skipped, num_skiped = self.embedder_local(data, col="Image")
self.assertIsNone(skipped)
self.assertEqual(0, num_skiped)
self.assertEqual(len(data), len(emb))
self.assertTupleEqual((len(data), 1000), emb.X.shape)
def test_table_skip(self):
data = Table("https://datasets.biolab.si/core/bone-healing.xlsx")
data.metas[0, 1] = "tralala"
emb, skipped, num_skiped = self.embedder_local(data, col="Image")
self.assertIsNotNone(skipped)
self.assertEqual(1, num_skiped)
self.assertEqual(len(data) - 1, len(emb))
self.assertTupleEqual((len(data) - 1, 1000), emb.X.shape)
@patch(HTTPX_POST_METHOD, make_dummy_post(b'{"embedding": [0, 1]}',
sleep=1))
def test_wait(self):
"""
Testing if __wait_until_released works correctly
"""
too_many_examples = [_EXAMPLE_IMAGE_JPG for _ in range(200)]
true_res = [np.array([0, 1], dtype=np.float16) for _ in range(200)]
true_res = np.array(true_res)
res = self.embedder_server(too_many_examples)
assert_array_equal(res, true_res)
def test_bad_arguments(self):
"""
Wrong arguments should raise TypeError
"""
with self.assertRaises(TypeError):
self.embedder_server('abc')
@patch(HTTPX_POST_METHOD, side_effect=OSError)
def test_connection_error(self, _):
for num_images in range(1, 20):
with self.assertRaises(ConnectionError):
self.embedder_server(self.single_example * num_images)
self.setUp() # to init new embedder
class ImageEmbedderTest(unittest.TestCase):
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def setUp(self):
logging.disable(logging.CRITICAL)
self.embedder_server = ImageEmbedder(
model='inception-v3',
layer='penultimate',
server_url='example.com',
)
self.embedder_server.clear_cache()
self.embedder_local = ImageEmbedder(
model='squeezenet',
layer='penultimate',
server_url='example.com',
)
self.embedder_local.clear_cache()
self.single_example = [_EXAMPLE_IMAGE_JPG]
def tearDown(self):
self.embedder_server.clear_cache()
logging.disable(logging.NOTSET)
@patch(_TESTED_MODULE.format('HTTP20Connection'))
def test_connected_to_server(self, ConnectionMock):
ConnectionMock._discover_server.assert_not_called()
self.assertEqual(self.embedder_server.is_connected_to_server(), True)
# server closes the connection
self.embedder_server._embedder._server_connection.close()
self.assertEqual(self.embedder_server.is_connected_to_server(), False)
@patch(_TESTED_MODULE.format('HTTP20Connection'))
def test_connection_errors(self, ConnectionMock):
res = self.embedder_server(self.single_example)
assert_array_equal(res, np.array([np.array([0, 1], dtype=np.float16)]))
self.embedder_server.clear_cache()
self.embedder_server._embedder._server_connection.close()
ConnectionMock.side_effect = ConnectionRefusedError
with self.assertRaises(ConnectionError):
self.embedder_server(self.single_example)
ConnectionMock.side_effect = BrokenPipeError
with self.assertRaises(ConnectionError):
self.embedder_server(self.single_example)
@patch.object(DummyHttp2Connection, 'get_response')
def test_on_stream_reset_by_server(self, ConnectionMock):
ConnectionMock.side_effect = StreamResetError
self.assertEqual(self.embedder_server(self.single_example), [None])
self.assertEqual(len(self.embedder_server._embedder._cache._cache_dict), 0)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_disconnect_reconnect(self):
self.assertEqual(self.embedder_server.is_connected_to_server(), True)
self.embedder_server._embedder.disconnect_from_server()
self.assertEqual(self.embedder_server.is_connected_to_server(), False)
self.embedder_server.reconnect_to_server()
self.assertEqual(self.embedder_server.is_connected_to_server(), True)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_auto_reconnect(self):
self.assertEqual(self.embedder_server.is_connected_to_server(), True)
self.embedder_server._embedder.disconnect_from_server()
self.assertEqual(self.embedder_server.is_connected_to_server(), False)
self.embedder_server(self.single_example)
self.assertEqual(self.embedder_server.is_connected_to_server(), True)
@patch(_TESTED_MODULE.format('HTTP20Connection'))
def test_with_non_existing_image(self, ConnectionMock):
self.single_example = ['/non_existing_image']
self.assertEqual(self.embedder_server(self.single_example), [None])
ConnectionMock.request.assert_not_called()
ConnectionMock.get_response.assert_not_called()
self.assertEqual(self.embedder_server._embedder._cache._cache_dict, {})
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_on_successful_response(self):
res = self.embedder_server(self.single_example)
assert_array_equal(res, np.array([np.array([0, 1], dtype=np.float16)]))
self.assertEqual(len(self.embedder_server._embedder._cache._cache_dict), 1)
@patch.object(
DummyHttp2Connection, 'get_response',
lambda self, _: BytesIO(b''))
def test_on_non_json_response(self):
self.assertEqual(self.embedder_server(self.single_example), [None])
self.assertEqual(len(self.embedder_server._embedder._cache._cache_dict), 0)
@patch.object(
DummyHttp2Connection, 'get_response',
lambda self, _: BytesIO(json.dumps({'wrong_key': None}).encode()))
def test_on_json_wrong_key_response(self):
self.assertEqual(self.embedder_server(self.single_example), [None])
self.assertEqual(len(self.embedder_server._embedder._cache._cache_dict), 0)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_persistent_caching(self):
self.assertEqual(len(self.embedder_server._embedder._cache._cache_dict), 0)
self.embedder_server(self.single_example)
self.assertEqual(len(self.embedder_server._embedder._cache._cache_dict), 1)
self.embedder_server._embedder._cache.persist_cache()
self.embedder_server = ImageEmbedder(
model='inception-v3',
layer='penultimate',
server_url='example.com',
)
self.assertEqual(len(self.embedder_server._embedder._cache._cache_dict), 1)
self.embedder_server.clear_cache()
self.embedder_server = ImageEmbedder(
model='inception-v3',
layer='penultimate',
server_url='example.com',
)
self.assertEqual(len(self.embedder_server._embedder._cache._cache_dict), 0)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_different_models_caches(self):
embedder = ImageEmbedder(
model='painters',
layer='penultimate',
server_url='example.com',
)
embedder.clear_cache()
self.assertEqual(len(embedder._embedder._cache._cache_dict), 0)
embedder(self.single_example)
self.assertEqual(len(embedder._embedder._cache._cache_dict), 1)
embedder._embedder._cache.persist_cache()
self.embedder_server = ImageEmbedder(
model='inception-v3',
layer='penultimate',
server_url='example.com',
)
self.assertEqual(len(self.embedder_server._embedder._cache._cache_dict), 0)
self.embedder_server._embedder._cache.persist_cache()
embedder = ImageEmbedder(
model='painters',
layer='penultimate',
server_url='example.com',
)
self.assertEqual(len(embedder._embedder._cache._cache_dict), 1)
embedder.clear_cache()
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_with_statement(self):
# server embedder
with self.embedder_server as embedder:
embedder(self.single_example)
self.assertEqual(self.embedder_server.is_connected_to_server(), False)
self.embedder_server = ImageEmbedder(
model='inception-v3',
layer='penultimate',
server_url='example.com',
)
self.assertEqual(
len(self.embedder_server._embedder._cache._cache_dict), 1)
# local embedder
with self.embedder_local as embedder:
embedder(self.single_example)
self.assertEqual(self.embedder_local.is_connected_to_server(), False)
self.embedder_local = ImageEmbedder(
model='squeezenet',
layer='penultimate',
server_url='example.com',
)
self.assertEqual(
len(self.embedder_local._embedder._cache._cache_dict), 1)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_max_concurrent_streams_setting(self):
self.assertEqual(self.embedder_server._embedder._max_concurrent_streams, 128)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_too_many_examples_for_one_batch(self):
too_many_examples = [_EXAMPLE_IMAGE_JPG for _ in range(200)]
true_res = [np.array([0, 1], dtype=np.float16) for _ in range(200)]
true_res = np.array(true_res)
res = self.embedder_server(too_many_examples)
assert_array_equal(res, true_res)
# no need to test it on local embedder since it does not work
# in batches
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_successful_result_shape(self):
# global embedder
more_examples = [_EXAMPLE_IMAGE_JPG for _ in range(5)]
res = self.embedder_server(more_examples)
self.assertEqual(res.shape, (5, 2))
# local embedder
more_examples = [_EXAMPLE_IMAGE_JPG for _ in range(5)]
res = self.embedder_local(more_examples)
self.assertEqual(res.shape, (5, 1000))
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_invalid_model(self):
with self.assertRaises(ValueError):
self.embedder_server = ImageEmbedder(
model='invalid_model',
layer='penultimate',
server_url='example.com',
)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_invalid_layer(self):
# test server embedder
with self.assertRaises(ValueError):
self.embedder_server = ImageEmbedder(
model='inception-v3',
layer='first',
server_url='example.com',
)
# test local embedder
with self.assertRaises(ValueError):
self.embedder_server = ImageEmbedder(
model='squeezenet',
layer='first',
server_url='example.com',
)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_with_grayscale_image(self):
# test server embedder
res = self.embedder_server([_EXAMPLE_IMAGE_GRAYSCALE])
assert_array_equal(res, np.array([np.array([0, 1], dtype=np.float16)]))
self.assertEqual(len(self.embedder_server._embedder._cache._cache_dict), 1)
# test local embedder
res = self.embedder_local([_EXAMPLE_IMAGE_GRAYSCALE])
self.assertEqual(
len(self.embedder_local._embedder._cache._cache_dict), 1)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_with_tiff_image(self):
# test server embedder
res = self.embedder_server([_EXAMPLE_IMAGE_TIFF])
assert_array_equal(res, np.array([np.array([0, 1], dtype=np.float16)]))
self.assertEqual(
len(self.embedder_server._embedder._cache._cache_dict), 1)
# test local embedder
res = self.embedder_local([_EXAMPLE_IMAGE_TIFF])
self.assertEqual(
len(self.embedder_local._embedder._cache._cache_dict), 1)
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_server_url_env_var(self):
url_value = 'url:1234'
self.assertTrue(self.embedder_server._embedder._server_url != url_value)
environ['ORANGE_EMBEDDING_API_URL'] = url_value
self.embedder_server = ImageEmbedder(
model='inception-v3',
layer='penultimate',
server_url='example.com',
)
self.assertTrue(self.embedder_server._embedder._server_url == url_value)
del environ['ORANGE_EMBEDDING_API_URL']
@patch(_TESTED_MODULE.format('HTTP20Connection'), DummyHttp2Connection)
def test_embedding_cancelled(self):
# test for the server embedders
self.assertFalse(self.embedder_server._embedder.cancelled)
self.embedder_server._embedder.cancelled = True
with self.assertRaises(Exception):
self.embedder_server(self.single_example)
# test for the local embedder
self.assertFalse(self.embedder_local._embedder.cancelled)
self.embedder_local._embedder.cancelled = True
with self.assertRaises(Exception):
self.embedder_local(self.single_example)
