def test_insert(self):
with deepstar_path():
video_model = VideoModel()
video_id = video_model.insert('test1', 'test2')
self.assertEqual(video_id, 1)
result = video_model.select(1)
self.assertEqual(result, (1, 'test1', 'test2', None))
def select_deploy(self, video_id, name, opts):
"""
This method deploys a video via a plugin.
:param int video_id: The video ID.
:param str name: The plugin name.
:param opts dict: The dict of options.
:rtype: None
"""
video_model = VideoModel()
result = video_model.select(video_id)
if result is None:
raise CommandLineRouteHandlerError(
f'Video with ID {video_id:08d} not found')
plugin = Plugin.get('video_select_deploy', name)
if plugin is None:
raise CommandLineRouteHandlerError(
f"'{name}' is not a valid frame set extraction plugin name")
plugin().video_select_deploy(video_id, opts)
debug('success', 3)
def test_delete_one(self):
with deepstar_path():
with mock.patch.dict(os.environ, {'DEBUG_LEVEL': '0'}):
route_handler = VideoCommandLineRouteHandler()
video_0001 = os.path.dirname(os.path.realpath(__file__)) + '/../../support/video_0001.mp4' # noqa
route_handler.insert_file(video_0001)
video_model = VideoModel()
old = video_model.select(1)
self.assertIsNotNone(old)
args = ['main.py', 'delete', 'videos', '1']
opts = {}
route_handler = VideoCommandLineRouteHandler()
try:
sys.stdout = StringIO()
route_handler.handle(args, opts)
actual = sys.stdout.getvalue().strip()
finally:
sys.stdout = sys.__stdout__
# stdout
self.assertEqual(actual, 'Video 1 was successfully deleted')
# db + files
new = video_model.select(1)
self.assertIsNone(new)
self.assertFalse(os.path.exists(VideoFile.path(old[2])))
def test_select_extract_many(self):
with deepstar_path():
video_0001 = os.path.dirname(os.path.realpath(__file__)) + '/../../support/video_0001.mp4' # noqa
shutil.copyfile(video_0001, VideoFile.path('video_0001.mp4'))
shutil.copyfile(video_0001, VideoFile.path('video_0002.mp4'))
shutil.copyfile(video_0001, VideoFile.path('video_0003.mp4'))
VideoModel().insert('test', 'video_0001.mp4')
VideoModel().insert('test', 'video_0002.mp4')
VideoModel().insert('test', 'video_0003.mp4')
args = ['main.py', 'select', 'videos', '1-2,3', 'extract']
opts = {}
route_handler = VideoCommandLineRouteHandler()
try:
sys.stdout = StringIO()
route_handler.handle(args, opts)
actual = sys.stdout.getvalue().strip()
finally:
sys.stdout = sys.__stdout__
# stdout
expected = textwrap.dedent('''
frame_set_id=1, video_id=1
frame_set_id=2, video_id=2
frame_set_id=3, video_id=3
''').strip()
self.assertEqual(actual, expected)
def select_extract(self, video_ids, opts={}):
"""
This method extracts frames and thumbnails from a video to a frame set.
:param list(int) video_ids: The video IDs.
:param dict opts: The optional dict of options.
:raises: CommandLineRouteHandlerError
:rtype: None
"""
video_model = VideoModel()
for video_id in video_ids:
result = video_model.select(video_id)
if result is None:
raise CommandLineRouteHandlerError(
f'Video with ID {video_id:08d} not found')
plugin = Plugin.get('video_select_extract', 'default')
for video_id in video_ids:
frame_set_id = plugin().video_select_extract(
video_id,
sub_sample=int(opts.get('sub-sample', 1)),
max_sample=int(opts.get('max-sample', 0)))
debug(f'frame_set_id={frame_set_id}, video_id={video_id}', 3)
def insert_vimeo_url(self, url, quality='hq', desc=None):
"""
This method inserts a Vimeo video into the video collection.
:param str url: The URL of the Vimeo video.
:param str desc: An optional description of the video.
:raises: CommandLineRouteHandlerError
:rtype: None
"""
try:
video = self.vimeo_context(url)
except KeyError:
raise CommandLineRouteHandlerError(
f'A KeyError exception was raised and caught for '
f'{url}')
if desc is None:
desc = self.vimeo_title(video)
stream = self.vimeo_stream(video, quality)
filename = f'{self.uuid()}.mp4'
self.vimeo_stream_download(stream, VideoDir.path(), filename)
video_id = VideoModel().insert(url, filename, desc)
debug(
f'video_id={video_id}, uri={url}, filename={filename}, '
f'description={desc}', 3)
def insert_youtube_url(self, url, desc=None):
"""
This method inserts a YouTube video into the video collection.
:param str url: The URL of the YouTube video.
:param str desc: An optional description of the video.
:raises: CommandLineRouteHandlerError
:rtype: None
"""
try:
context = self.youtube_context(url)
except pytube.exceptions.VideoUnavailable:
raise CommandLineRouteHandlerError(
f'A VideoUnavailable exception was raised and caught for '
f'{url}')
streams = self.youtube_streams(context)
stream = self.youtube_select(streams)
try:
path = self.youtube_download(context, stream[0], VideoDir.path(),
self.uuid())
except urllib.error.HTTPError as e: # noqa
raise CommandLineRouteHandlerError(
f'An HTTPError exception was raised and caught for {url} '
f'with HTTP status code {e.code}')
filename = os.path.basename(path)
video_id = VideoModel().insert(url, filename, desc)
debug(
f'video_id={video_id}, uri={url}, filename={filename}, '
f'description={desc}', 3)
def test_select_deploy(self):
with deepstar_path():
video_0001 = os.path.dirname(os.path.realpath(__file__)) + '/../../support/video_0001.mp4' # noqa
shutil.copyfile(video_0001, VideoFile.path('video_0001.mp4'))
VideoModel().insert('test', 'video_0001.mp4')
class TestPlugin:
def video_select_deploy(self, video_id, opts):
pass
args = ['main.py', 'select', 'videos', '1', 'deploy', 'test']
opts = {}
route_handler = VideoCommandLineRouteHandler()
try:
sys.stdout = StringIO()
with mock.patch.dict(Plugin._map, {'video_select_deploy': {'test': TestPlugin}}): # noqa
route_handler.handle(args, opts)
actual = sys.stdout.getvalue().strip()
finally:
sys.stdout = sys.__stdout__
# stdout
self.assertEqual(actual, 'success')
def test_insert_file_description(self):
with deepstar_path():
video_0001 = os.path.dirname(os.path.realpath(__file__)) + '/../../support/video_0001.mp4' # noqa
class TestVideoCommandLineRouteHandler_(VideoCommandLineRouteHandler): # noqa
def uuid(self):
return '12345678-1234-1234-1234-123456789012'
args = ['main.py', 'insert', 'videos', 'file', video_0001]
opts = {'description': 'test'}
route_handler = TestVideoCommandLineRouteHandler_()
try:
sys.stdout = StringIO()
route_handler.handle(args, opts)
actual = sys.stdout.getvalue().strip()
finally:
sys.stdout = sys.__stdout__
# stdout
expected = 'video_id=1, uri=' + video_0001 + ', filename=12345678-1234-1234-1234-123456789012.mp4, description=test' # noqa
self.assertEqual(actual, expected)
# db
result = VideoModel().select(1)
self.assertEqual(len(result), 4)
self.assertEqual(result[0], 1)
self.assertEqual(result[1], video_0001)
UUID(result[2].rstrip('.mp4'), version=4)
self.assertEqual(result[3], 'test')
def test_transform_set_select_extract_max_size(self):
with deepstar_path():
video_0001 = os.path.dirname(os.path.realpath(
__file__)) + '/../../support/video_0001.mp4' # noqa
shutil.copyfile(video_0001, VideoFile.path('video_0001.mp4'))
VideoModel().insert('test', 'video_0001.mp4')
DefaultVideoSelectExtractPlugin().video_select_extract(1) # noqa
self.mock_transform_set()
with mock.patch.dict(os.environ, {'MODEL_LIST_LENGTH': '2'}):
transform_set_id = MaxSizeTransformSetSelectExtractPlugin(
).transform_set_select_extract(1, {}) # noqa
self.assertEqual(transform_set_id, 2)
# db
result = TransformSetModel().select(2)
self.assertEqual(result, (2, 'max_size', 1, 1))
result = TransformModel().list(2)
self.assertEqual(len(result), 5)
t = list(result[0])
json.loads(t.pop(3))
self.assertEqual(t, [6, 2, 1, 0])
t = list(result[1])
json.loads(t.pop(3))
self.assertEqual(t, [7, 2, 2, 0])
t = list(result[2])
json.loads(t.pop(3))
self.assertEqual(t, [8, 2, 3, 0])
t = list(result[3])
json.loads(t.pop(3))
self.assertEqual(t, [9, 2, 4, 0])
t = list(result[4])
json.loads(t.pop(3))
self.assertEqual(t, [10, 2, 5, 0])
# files
p1 = TransformSetSubDir.path(2)
# transforms
self.assertEqual(
cv2.imread(TransformFile.path(p1, 6, 'jpg')).shape[0],
299) # noqa
self.assertEqual(
cv2.imread(TransformFile.path(p1, 7, 'jpg')).shape[0],
299) # noqa
self.assertEqual(
cv2.imread(TransformFile.path(p1, 8, 'jpg')).shape[0],
299) # noqa
self.assertEqual(
cv2.imread(TransformFile.path(p1, 9, 'jpg')).shape[0],
299) # noqa
self.assertEqual(
cv2.imread(TransformFile.path(p1, 10, 'jpg')).shape[0],
299) # noqa
def test_transform_set_select_curate_min_size_fails_due_to_missing_required_option(
self): # noqa
with deepstar_path():
video_0001 = os.path.dirname(os.path.realpath(
__file__)) + '/../../support/video_0001.mp4' # noqa
shutil.copyfile(video_0001, VideoFile.path('video_0001.mp4'))
VideoModel().insert('test', 'video_0001.mp4')
DefaultVideoSelectExtractPlugin().video_select_extract(1) # noqa
self.mock_transform_set()
with self.assertRaises(ValueError):
try:
MinSizeTransformSetSelectCuratePlugin(
).transform_set_select_curate(1, {}) # noqa
except ValueError as e:
self.assertEqual(
str(e),
'The min-size option is required but was not supplied'
) # noqa
raise e
def test_insert_youtube_url_file(self):
with deepstar_path():
video_0001 = os.path.dirname(os.path.realpath(__file__)) + '/../../support/video_0001.mp4' # noqa
class TestVideoCommandLineRouteHandler_(VideoCommandLineRouteHandler): # noqa
def uuid(self):
return '12345678-1234-1234-1234-123456789012'
args = ['main.py', 'insert', 'videos', 'youtube', 'https://www.youtube.com/watch?v=test'] # noqa
opts = {'file': video_0001}
route_handler = TestVideoCommandLineRouteHandler_()
try:
sys.stdout = StringIO()
route_handler.handle(args, opts)
actual = sys.stdout.getvalue().strip()
finally:
sys.stdout = sys.__stdout__
# stdout
self.assertIsNotNone(re.match('^video_id=1, uri=.*video_0001.mp4, filename=12345678-1234-1234-1234-123456789012.mp4, description=None$', actual)) # noqa
# db + files
result = VideoModel().select(1)
self.assertEqual(len(result), 4)
self.assertEqual(result[0], 1)
self.assertIsNotNone(re.match('^.*video_0001.mp4', result[1]))
UUID(result[2].rstrip('.mp4'), version=4)
self.assertTrue(os.path.isfile(VideoFile.path(result[2])))
self.assertEqual(result[3], None)
def test_list(self):
with deepstar_path():
VideoModel().insert('test1', 'test2')
FrameSetModel().insert(1)
frame_model = FrameModel()
frame_model.insert(1, 0)
frame_model.insert(1, 1)
frame_model.insert(1, 0)
result = frame_model.list(1)
self.assertEqual(len(result), 3)
self.assertEqual(result[0], (1, 1, 0))
self.assertEqual(result[1], (2, 1, 1))
self.assertEqual(result[2], (3, 1, 0))
result = frame_model.list(1, length=2)
self.assertEqual(len(result), 2)
self.assertEqual(result[0], (1, 1, 0))
self.assertEqual(result[1], (2, 1, 1))
result = frame_model.list(1, offset=1)
self.assertEqual(len(result), 2)
self.assertEqual(result[0], (2, 1, 1))
self.assertEqual(result[1], (3, 1, 0))
result = frame_model.list(1, length=1, offset=1)
self.assertEqual(len(result), 1)
self.assertEqual(result[0], (2, 1, 1))
result = frame_model.list(1, rejected=False)
self.assertEqual(len(result), 2)
self.assertEqual(result[0], (1, 1, 0))
self.assertEqual(result[1], (3, 1, 0))
def test_select(self):
with deepstar_path():
VideoModel().insert('test1', 'test2')
frame_set_model = FrameSetModel()
frame_set_model.insert(1)
result = frame_set_model.select(1)
self.assertEqual(result, (1, 1))
def test_video_select_extract(self):
with deepstar_path():
video_0001 = os.path.dirname(os.path.realpath(
__file__)) + '/../../support/video_0001.mp4' # noqa
shutil.copyfile(video_0001, VideoFile.path('video_0001.mp4'))
VideoModel().insert('test', 'video_0001.mp4')
frame_set_id = DefaultVideoSelectExtractPlugin(
).video_select_extract(1) # noqa
self.assertEqual(frame_set_id, 1)
# db
result = FrameSetModel().select(1)
self.assertEqual(result, (1, 1))
result = FrameModel().list(1)
self.assertEqual(len(result), 5)
self.assertEqual(result[0], (1, 1, 0))
self.assertEqual(result[1], (2, 1, 0))
self.assertEqual(result[2], (3, 1, 0))
self.assertEqual(result[3], (4, 1, 0))
self.assertEqual(result[4], (5, 1, 0))
# files
p1 = FrameSetSubDir.path(1)
# frames
self.assertIsInstance(cv2.imread(FrameFile.path(p1, 1, 'jpg')),
np.ndarray) # noqa
self.assertIsInstance(cv2.imread(FrameFile.path(p1, 2, 'jpg')),
np.ndarray) # noqa
self.assertIsInstance(cv2.imread(FrameFile.path(p1, 3, 'jpg')),
np.ndarray) # noqa
self.assertIsInstance(cv2.imread(FrameFile.path(p1, 4, 'jpg')),
np.ndarray) # noqa
self.assertIsInstance(cv2.imread(FrameFile.path(p1, 5, 'jpg')),
np.ndarray) # noqa
# thumbnails
self.assertEqual(
cv2.imread(FrameFile.path(p1, 1, 'jpg', '192x192')).shape[1],
192) # noqa
self.assertEqual(
cv2.imread(FrameFile.path(p1, 2, 'jpg', '192x192')).shape[1],
192) # noqa
self.assertEqual(
cv2.imread(FrameFile.path(p1, 3, 'jpg', '192x192')).shape[1],
192) # noqa
self.assertEqual(
cv2.imread(FrameFile.path(p1, 4, 'jpg', '192x192')).shape[1],
192) # noqa
self.assertEqual(
cv2.imread(FrameFile.path(p1, 5, 'jpg', '192x192')).shape[1],
192) # noqa
def test_insert_youtube_file_description(self):
with deepstar_path():
video_0001 = os.path.dirname(os.path.realpath(__file__)) + '/../../support/video_0001.mp4' # noqa
class TestVideoCommandLineRouteHandler_(VideoCommandLineRouteHandler): # noqa
def youtube_context(self, url):
return None
def youtube_streams(self, context):
return [
['22', 'video/mp4', '720p']
]
def uuid(self):
return '12345678-1234-1234-1234-123456789012'
def youtube_download(self, context, stream, output_path, filename): # noqa
filename = filename + '.mp4'
shutil.copyfile(video_0001, output_path + '/' + filename)
return filename
path = os.environ['DEEPSTAR_PATH'] + '/test.txt'
with open(path, 'w') as file_:
file_.write('https://www.youtube.com/watch?v=test1, test')
args = ['main.py', 'insert', 'videos', 'youtube', path]
opts = {}
route_handler = TestVideoCommandLineRouteHandler_()
try:
sys.stdout = StringIO()
route_handler.handle(args, opts)
actual = sys.stdout.getvalue().strip()
finally:
sys.stdout = sys.__stdout__
# stdout
expected = \
'video_id=1, uri=https://www.youtube.com/watch?v=test1, ' \
'filename=12345678-1234-1234-1234-123456789012.mp4, ' \
'description=test' \
self.assertEqual(actual, expected)
# db + files
result = VideoModel().select(1)
self.assertEqual(result[0], 1)
self.assertEqual(result[1], 'https://www.youtube.com/watch?v=test1') # noqa
UUID(result[2].rstrip('.mp4'), version=4)
self.assertTrue(os.path.isfile(VideoFile.path(result[2])))
self.assertEqual(result[3], 'test')
def test_transform_set_select_extract_pad_rejected(self):
with deepstar_path():
video_0001 = os.path.dirname(os.path.realpath(
__file__)) + '/../../support/video_0001.mp4' # noqa
shutil.copyfile(video_0001, VideoFile.path('video_0001.mp4'))
VideoModel().insert('test', 'video_0001.mp4')
DefaultVideoSelectExtractPlugin().video_select_extract(1) # noqa
self.mock_transform_set()
MaxSizeTransformSetSelectExtractPlugin(
).transform_set_select_extract(1, {}) # noqa
transform_model = TransformModel()
transform_model.update(7, rejected=1)
transform_model.update(9, rejected=1)
with mock.patch.dict(os.environ, {'MODEL_LIST_LENGTH': '2'}):
transform_set_id = PadTransformSetSelectExtractPlugin(
).transform_set_select_extract(2, {}) # noqa
self.assertEqual(transform_set_id, 3)
# db
result = TransformSetModel().select(3)
self.assertEqual(result, (3, 'pad', 1, 2))
result = TransformModel().list(3)
self.assertEqual(len(result), 3)
t = list(result[0])
json.loads(t.pop(3))
self.assertEqual(t, [11, 3, 1, 0])
t = list(result[1])
json.loads(t.pop(3))
self.assertEqual(t, [12, 3, 3, 0])
t = list(result[2])
json.loads(t.pop(3))
self.assertEqual(t, [13, 3, 5, 0])
# files
p1 = TransformSetSubDir.path(3)
# transforms
self.assertIsInstance(cv2.imread(TransformFile.path(p1, 11,
'jpg')),
np.ndarray) # noqa
self.assertIsInstance(cv2.imread(TransformFile.path(p1, 12,
'jpg')),
np.ndarray) # noqa
self.assertIsInstance(cv2.imread(TransformFile.path(p1, 13,
'jpg')),
np.ndarray) # noqa
def test_update(self):
with deepstar_path():
video_model = VideoModel()
video_model.insert('test1', 'test2')
result = video_model.select(1)
self.assertEqual(result, (1, 'test1', 'test2', None))
video_model.update(1, uri='test3')
result = video_model.select(1)
self.assertEqual(result, (1, 'test3', 'test2', None))
def test_select(self):
with deepstar_path():
VideoModel().insert('test1', 'test2')
FrameSetModel().insert(1)
transform_set_model = TransformSetModel()
transform_set_model.insert('test', 1)
result = transform_set_model.select(1)
self.assertEqual(result, (1, 'test', 1, None))
def test_count_rejected_false(self):
with deepstar_path():
VideoModel().insert('test1', 'test2')
FrameSetModel().insert(1)
frame_model = FrameModel()
frame_model.insert(1, 0)
frame_model.insert(1, 1)
frame_model.insert(1, 0)
self.assertEqual(frame_model.count(1, rejected=False), 2)
def test_insert_image_description(self):
with deepstar_path():
image_0001 = os.path.dirname(os.path.realpath(__file__)) + '/../../support/image_0001.jpg' # noqa
args = ['main.py', 'insert', 'videos', 'image', image_0001]
opts = {'description': 'test'}
with mock.patch.dict(os.environ, {'DEBUG_LEVEL': '0'}):
VideoCommandLineRouteHandler().handle(args, opts)
# db
self.assertEqual(VideoModel().select(1)[3], 'test')
def test_delete(self):
with deepstar_path():
video_model = VideoModel()
video_model.insert('test1', 'test2')
result = video_model.select(1)
self.assertEqual(result, (1, 'test1', 'test2', None))
result = video_model.delete(1)
self.assertTrue(result)
result = video_model.select(1)
self.assertIsNone(result)
def test_count(self):
with deepstar_path():
VideoModel().insert('test1', 'test2')
FrameSetModel().insert(1)
frame_model = FrameModel()
frame_model.insert(1, 0)
frame_model.insert(1, 0)
frame_model.insert(1, 0)
self.assertEqual(frame_model.count(1), 3)
def test_list(self):
with deepstar_path():
video_model = VideoModel()
video_model.insert('test1', 'test2')
video_model.insert('test3', 'test4')
video_model.insert('test5', 'test6')
args = ['main.py', 'list', 'videos']
opts = {}
route_handler = VideoCommandLineRouteHandler()
try:
sys.stdout = StringIO()
route_handler.handle(args, opts)
actual = sys.stdout.getvalue().strip()
finally:
sys.stdout = sys.__stdout__
# stdout
expected = textwrap.dedent('''
3 results
id | uri | filename | description
---------------------------------
1 | test1 | test2 | None
2 | test3 | test4 | None
3 | test5 | test6 | None''').strip()
self.assertEqual(actual, expected)
def test_list(self):
with deepstar_path():
video_model = VideoModel()
video_model.insert('test1', 'test2')
video_model.insert('test3', 'test4')
video_model.insert('test5', 'test6')
frame_set_model = FrameSetModel()
frame_set_model.insert(1)
frame_set_model.insert(2)
frame_set_model.insert(3)
args = ['main.py', 'list', 'frame_sets']
opts = {}
route_handler = FrameSetCommandLineRouteHandler()
try:
sys.stdout = StringIO()
route_handler.handle(args, opts)
actual = sys.stdout.getvalue().strip()
finally:
sys.stdout = sys.__stdout__
# stdout
expected = textwrap.dedent('''
3 results
id | fk_videos
-------------
1 | 1
2 | 2
3 | 3''').strip()
self.assertEqual(actual, expected)
def delete(self, video_ids):
"""
This method deletes a video from the video collection.
:param list(ints) video_ids: The video IDs.
:raises: CommandLineRouteHandlerError
:rtype: None
"""
video_model = VideoModel()
for video_id in video_ids:
result = video_model.select(video_id)
if result is None:
raise CommandLineRouteHandlerError(
f'Video with ID {video_id:08d} not found')
for video_id in video_ids:
result = video_model.select(video_id)
path = VideoFile.path(result[2])
video_model.delete(video_id)
os.remove(path)
debug(f'Video {video_id} was successfully deleted', 3)
def test_list(self):
with deepstar_path():
video_model = VideoModel()
video_model.insert('test1', 'test2')
video_model.insert('test3', 'test4')
video_model.insert('test5', 'test6')
result = video_model.list()
self.assertEqual(len(result), 3)
self.assertEqual(result[0], (1, 'test1', 'test2', None))
self.assertEqual(result[1], (2, 'test3', 'test4', None))
self.assertEqual(result[2], (3, 'test5', 'test6', None))
def test_select_extract_one(self):
with deepstar_path():
video_0001 = os.path.dirname(os.path.realpath(__file__)) + '/../../support/video_0001.mp4' # noqa
shutil.copyfile(video_0001, VideoFile.path('video_0001.mp4'))
VideoModel().insert('test', 'video_0001.mp4')
args = ['main.py', 'select', 'videos', '1', 'extract']
opts = {}
route_handler = VideoCommandLineRouteHandler()
try:
sys.stdout = StringIO()
route_handler.handle(args, opts)
actual = sys.stdout.getvalue().strip()
finally:
sys.stdout = sys.__stdout__
# stdout
self.assertEqual(actual, 'frame_set_id=1, video_id=1')
# db
result = FrameSetModel().select(1)
self.assertEqual(result, (1, 1))
result = FrameModel().list(1)
self.assertEqual(len(result), 5)
self.assertEqual(result[0], (1, 1, 0))
self.assertEqual(result[1], (2, 1, 0))
self.assertEqual(result[2], (3, 1, 0))
self.assertEqual(result[3], (4, 1, 0))
self.assertEqual(result[4], (5, 1, 0))
# files
p1 = FrameSetSubDir.path(1)
# frames
self.assertTrue(os.path.isfile(FrameFile.path(p1, 1, 'jpg')))
self.assertTrue(os.path.isfile(FrameFile.path(p1, 2, 'jpg')))
self.assertTrue(os.path.isfile(FrameFile.path(p1, 3, 'jpg')))
self.assertTrue(os.path.isfile(FrameFile.path(p1, 4, 'jpg')))
self.assertTrue(os.path.isfile(FrameFile.path(p1, 5, 'jpg')))
# thumbnails
self.assertTrue(os.path.isfile(FrameFile.path(p1, 1, 'jpg', '192x192'))) # noqa
self.assertTrue(os.path.isfile(FrameFile.path(p1, 2, 'jpg', '192x192'))) # noqa
self.assertTrue(os.path.isfile(FrameFile.path(p1, 3, 'jpg', '192x192'))) # noqa
self.assertTrue(os.path.isfile(FrameFile.path(p1, 4, 'jpg', '192x192'))) # noqa
self.assertTrue(os.path.isfile(FrameFile.path(p1, 5, 'jpg', '192x192'))) # noqa
def select_detect(self, video_id, model_name, opts):
"""
This method runs a deepfake detection model over a video.
:param int video_id: The video ID.
:param str model_name: The name of the detection model to run.
:param opts dict: The dict of options.
"""
video_model = VideoModel()
result = video_model.select(video_id)
if result is None:
raise CommandLineRouteHandlerError(
f'Video with ID {video_id:08d} not found')
plugin = Plugin.get('video_select_detect', model_name)
if plugin is None:
raise CommandLineRouteHandlerError(
f"'{model_name}' is not a valid video select detect plugin name")
video_path = VideoFile.path(result[2])
plugin().video_select_detect(video_path, **opts)
def test_list(self):
with deepstar_path():
VideoModel().insert('test1', 'test2')
frame_set_model = FrameSetModel()
frame_set_model.insert(1)
frame_set_model.insert(1)
frame_set_model.insert(1)
result = frame_set_model.list()
self.assertEqual(len(result), 3)
self.assertEqual(result[0], (1, 1))
self.assertEqual(result[1], (2, 1))
self.assertEqual(result[2], (3, 1))
