示例#1
0
    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)
示例#2
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))
示例#3
0
 def test_fk_frame_sets_on_delete_cascade(self):
     with deepstar_path():
         frame_set_model = FrameSetModel()
         frame_set_model.insert(1)
         frame_model = FrameModel()
         frame_model.insert(1, 0)
         self.assertEqual(frame_model.list(1), [(1, 1, 0)])
         frame_set_model.delete(1)
         self.assertIsNone(frame_model.list(1))
示例#4
0
 def test_delete(self):
     with deepstar_path():
         frame_set_model = FrameSetModel()
         frame_set_model.insert(1)
         result = frame_set_model.select(1)
         self.assertEqual(result, (1, 1))
         result = frame_set_model.delete(1)
         self.assertTrue(result)
         result = frame_set_model.select(1)
         self.assertIsNone(result)
示例#5
0
    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))
    def select_merge(self, frame_set_ids, video_id=None, rejected=False):
        """
        This method merges multiple frame sets into one frame set.

        :param list(int) frame_set_ids: The frame set IDs.
        :param int video_id: The video ID to which this frame set corresponds
             (if any). The default value is None.
        :param bool rejected: True if should include rejected frames else False
            if should not. The default value is False.
        :raises: CommandLineRouteHandlerError
        :rtype: None
        """

        frame_set_model = FrameSetModel()

        for frame_set_id in frame_set_ids:
            result = frame_set_model.select(frame_set_id)
            if result is None:
                raise CommandLineRouteHandlerError(
                    f'Frame set with ID {frame_set_id:08d} not found')

        frame_set_id = frame_set_model.insert(video_id)

        p1 = FrameSetSubDir.path(frame_set_id)

        os.makedirs(p1)

        frame_model = FrameModel()
        length = int(os.environ.get('MODEL_LIST_LENGTH', '100'))

        for frame_set_id_ in frame_set_ids:
            offset = 0
            p2 = FrameSetSubDir.path(frame_set_id_)

            while True:
                frames = frame_model.list(frame_set_id_,
                                          length=length,
                                          offset=offset,
                                          rejected=rejected)

                if not frames:
                    break

                for frame in frames:
                    frame_id = frame_model.insert(frame_set_id, frame[2])

                    p3 = FrameFile.path(p2, frame[0], 'jpg')
                    p4 = FrameFile.path(p2, frame[0], 'jpg', '192x192')
                    p5 = FrameFile.path(p1, frame_id, 'jpg')
                    p6 = FrameFile.path(p1, frame_id, 'jpg', '192x192')

                    shutil.copy(p3, p5)
                    shutil.copy(p4, p6)

                    debug(
                        f'Frame with ID {frame[0]:08d} and thumbnail at '
                        f'{p3} and {p4} merged as ID {frame_id:08d} at '
                        f'{p5} and {p6}', 4)

                offset += length

        debug(f'frame_set_id={frame_set_id}, fk_videos={video_id}', 3)