Exemplo n.º 1
0
 def setUp(self):
     self.fileSystem = Mock()
     self.imageReader = Mock()
     self.fileSystem.joinPath = MagicMock(
         side_effect=lambda x, y: x + '/' + y)
     self.sourceFolder = 'source'
     self.target = ImageDataSource(fileSystem=self.fileSystem,
                                   imageReader=self.imageReader,
                                   sourceFolder=self.sourceFolder)
 def CreateWithImageReader(imageReader, sourceFolder, log = False, loadOnlyClasses = None, getLabelFunction = None):
     if getLabelFunction is None:
         getLabelFunction = GetLabelFromFirstChars(nChars=2)
     imageDataSource =  ImageDataSource(fileSystem = FileSystem(),
                           imageReader = imageReader,
                           sourceFolder = sourceFolder)
                           
     if log:
         imageDataSource.setLogger(TextLogger())
     if loadOnlyClasses is not None:
         imageDataSource.setFilenamePredicate(LabelInFilenamePredicate(getLabelFunction, loadOnlyClasses))
     return imageDataSource
Exemplo n.º 3
0
 def test_writesToLog_ifLoggerIsInformed(self):
     logger = Mock()
     self.fileSystem.listDir.return_value = ['file.jpg', 'file2.jpg', 'file3.jpg']
     self.fileSystem.isFile.return_value = True 
     self.imageReader.read.return_value = Mock()
     
     target = ImageDataSource(fileSystem = self.fileSystem, 
                              imageReader = self.imageReader, 
                              sourceFolder = self.sourceFolder)
     target.setLogger(logger)
     target.load()
     
     logger.log.assert_has_calls([call('Reading file %s' % name) for name in ['file.jpg', 'file2.jpg', 'file3.jpg']])
Exemplo n.º 4
0
 def test_appliesFilter_ifFilterInformed(self):
     predicate = lambda x: x in ['file.jpg', 'file3.jpg']
     self.fileSystem.listDir.return_value = ['file.jpg', 'file2.jpg', 'file3.jpg']
     self.fileSystem.isFile.return_value = True 
     self.imageReader.read.return_value = Mock()
     
     target = ImageDataSource(fileSystem = self.fileSystem, 
                              imageReader = self.imageReader, 
                              sourceFolder = self.sourceFolder)
     target.setFilenamePredicate(predicate)
     target.load()
     
     self.imageReader.read.assert_has_calls([call(self.sourceFolder,'file.jpg'), call(self.sourceFolder,'file3.jpg')])
     self.assertEqual(len(self.imageReader.read.call_args_list), 2)
Exemplo n.º 5
0
    def CreateWithImageReader(imageReader,
                              sourceFolder,
                              log=False,
                              loadOnlyClasses=None,
                              getLabelFunction=None):
        if getLabelFunction is None:
            getLabelFunction = GetLabelFromFirstChars(nChars=2)
        imageDataSource = ImageDataSource(fileSystem=FileSystem(),
                                          imageReader=imageReader,
                                          sourceFolder=sourceFolder)

        if log:
            imageDataSource.setLogger(TextLogger())
        if loadOnlyClasses is not None:
            imageDataSource.setFilenamePredicate(
                LabelInFilenamePredicate(getLabelFunction, loadOnlyClasses))
        return imageDataSource
Exemplo n.º 6
0
    def test_writesToLog_ifLoggerIsInformed(self):
        logger = Mock()
        self.fileSystem.listDir.return_value = [
            'file.jpg', 'file2.jpg', 'file3.jpg'
        ]
        self.fileSystem.isFile.return_value = True
        self.imageReader.read.return_value = Mock()

        target = ImageDataSource(fileSystem=self.fileSystem,
                                 imageReader=self.imageReader,
                                 sourceFolder=self.sourceFolder)
        target.setLogger(logger)
        target.load()

        logger.log.assert_has_calls([
            call('Reading file %s' % name)
            for name in ['file.jpg', 'file2.jpg', 'file3.jpg']
        ])
Exemplo n.º 7
0
    def test_appliesFilter_ifFilterInformed(self):
        predicate = lambda x: x in ['file.jpg', 'file3.jpg']
        self.fileSystem.listDir.return_value = [
            'file.jpg', 'file2.jpg', 'file3.jpg'
        ]
        self.fileSystem.isFile.return_value = True
        self.imageReader.read.return_value = Mock()

        target = ImageDataSource(fileSystem=self.fileSystem,
                                 imageReader=self.imageReader,
                                 sourceFolder=self.sourceFolder)
        target.setFilenamePredicate(predicate)
        target.load()

        self.imageReader.read.assert_has_calls([
            call(self.sourceFolder, 'file.jpg'),
            call(self.sourceFolder, 'file3.jpg')
        ])
        self.assertEqual(len(self.imageReader.read.call_args_list), 2)
Exemplo n.º 8
0
 def setUp(self):
     self.fileSystem = Mock()
     self.imageReader = Mock()
     self.fileSystem.joinPath = MagicMock(side_effect = lambda x,y: x + '/' + y)
     self.sourceFolder = 'source'
     self.target = ImageDataSource(fileSystem = self.fileSystem, imageReader = self.imageReader, sourceFolder = self.sourceFolder)
Exemplo n.º 9
0
class testImageDataSource(unittest.TestCase):
    
    def setUp(self):
        self.fileSystem = Mock()
        self.imageReader = Mock()
        self.fileSystem.joinPath = MagicMock(side_effect = lambda x,y: x + '/' + y)
        self.sourceFolder = 'source'
        self.target = ImageDataSource(fileSystem = self.fileSystem, imageReader = self.imageReader, sourceFolder = self.sourceFolder)
    
    def testLoadImages(self):       
        image = Mock()
        
        self.fileSystem.listDir.return_value = ['file.jpg']
        self.fileSystem.isFile.return_value = True
        self.imageReader.read.return_value = image
        
        images = self.target.load()
        
        self.fileSystem.listDir.assert_called_with(self.sourceFolder)
        self.imageReader.read.assert_called_with(self.sourceFolder,'file.jpg')
        self.assertEqual(images, [image])

    def test_foldersAreIgnored(self):
        image = Mock()
        self.fileSystem.listDir.return_value = ['file.jpg', 'garbage']
        self.fileSystem.isFile = MagicMock(side_effect = lambda x: x == '%s/file.jpg' %self.sourceFolder)
        self.imageReader.read.return_value = image        
        
        self.target.load()
        
        self.imageReader.read.assert_called_with(self.sourceFolder,'file.jpg')
        
    def test_multipleImages(self):
        image = Mock()
        self.fileSystem.listDir.return_value = ['file.jpg', 'file2.jpg', 'file3.jpg']
        self.fileSystem.isFile.return_value = True 
        self.imageReader.read.return_value = image
        
        images = self.target.load()
        
        self.imageReader.read.assert_has_calls([call(self.sourceFolder,'file.jpg'), call(self.sourceFolder,'file2.jpg'), call(self.sourceFolder,'file3.jpg')])
        self.assertEqual(images, [image, image, image])

    def test_writesToLog_ifLoggerIsInformed(self):
        logger = Mock()
        self.fileSystem.listDir.return_value = ['file.jpg', 'file2.jpg', 'file3.jpg']
        self.fileSystem.isFile.return_value = True 
        self.imageReader.read.return_value = Mock()
        
        target = ImageDataSource(fileSystem = self.fileSystem, 
                                 imageReader = self.imageReader, 
                                 sourceFolder = self.sourceFolder)
        target.setLogger(logger)
        target.load()
        
        logger.log.assert_has_calls([call('Reading file %s' % name) for name in ['file.jpg', 'file2.jpg', 'file3.jpg']])

    def test_appliesFilter_ifFilterInformed(self):
        predicate = lambda x: x in ['file.jpg', 'file3.jpg']
        self.fileSystem.listDir.return_value = ['file.jpg', 'file2.jpg', 'file3.jpg']
        self.fileSystem.isFile.return_value = True 
        self.imageReader.read.return_value = Mock()
        
        target = ImageDataSource(fileSystem = self.fileSystem, 
                                 imageReader = self.imageReader, 
                                 sourceFolder = self.sourceFolder)
        target.setFilenamePredicate(predicate)
        target.load()
        
        self.imageReader.read.assert_has_calls([call(self.sourceFolder,'file.jpg'), call(self.sourceFolder,'file3.jpg')])
        self.assertEqual(len(self.imageReader.read.call_args_list), 2)
Exemplo n.º 10
0
class testImageDataSource(unittest.TestCase):
    def setUp(self):
        self.fileSystem = Mock()
        self.imageReader = Mock()
        self.fileSystem.joinPath = MagicMock(
            side_effect=lambda x, y: x + '/' + y)
        self.sourceFolder = 'source'
        self.target = ImageDataSource(fileSystem=self.fileSystem,
                                      imageReader=self.imageReader,
                                      sourceFolder=self.sourceFolder)

    def testLoadImages(self):
        image = Mock()

        self.fileSystem.listDir.return_value = ['file.jpg']
        self.fileSystem.isFile.return_value = True
        self.imageReader.read.return_value = image

        images = self.target.load()

        self.fileSystem.listDir.assert_called_with(self.sourceFolder)
        self.imageReader.read.assert_called_with(self.sourceFolder, 'file.jpg')
        self.assertEqual(images, [image])

    def test_foldersAreIgnored(self):
        image = Mock()
        self.fileSystem.listDir.return_value = ['file.jpg', 'garbage']
        self.fileSystem.isFile = MagicMock(
            side_effect=lambda x: x == '%s/file.jpg' % self.sourceFolder)
        self.imageReader.read.return_value = image

        self.target.load()

        self.imageReader.read.assert_called_with(self.sourceFolder, 'file.jpg')

    def test_multipleImages(self):
        image = Mock()
        self.fileSystem.listDir.return_value = [
            'file.jpg', 'file2.jpg', 'file3.jpg'
        ]
        self.fileSystem.isFile.return_value = True
        self.imageReader.read.return_value = image

        images = self.target.load()

        self.imageReader.read.assert_has_calls([
            call(self.sourceFolder, 'file.jpg'),
            call(self.sourceFolder, 'file2.jpg'),
            call(self.sourceFolder, 'file3.jpg')
        ])
        self.assertEqual(images, [image, image, image])

    def test_writesToLog_ifLoggerIsInformed(self):
        logger = Mock()
        self.fileSystem.listDir.return_value = [
            'file.jpg', 'file2.jpg', 'file3.jpg'
        ]
        self.fileSystem.isFile.return_value = True
        self.imageReader.read.return_value = Mock()

        target = ImageDataSource(fileSystem=self.fileSystem,
                                 imageReader=self.imageReader,
                                 sourceFolder=self.sourceFolder)
        target.setLogger(logger)
        target.load()

        logger.log.assert_has_calls([
            call('Reading file %s' % name)
            for name in ['file.jpg', 'file2.jpg', 'file3.jpg']
        ])

    def test_appliesFilter_ifFilterInformed(self):
        predicate = lambda x: x in ['file.jpg', 'file3.jpg']
        self.fileSystem.listDir.return_value = [
            'file.jpg', 'file2.jpg', 'file3.jpg'
        ]
        self.fileSystem.isFile.return_value = True
        self.imageReader.read.return_value = Mock()

        target = ImageDataSource(fileSystem=self.fileSystem,
                                 imageReader=self.imageReader,
                                 sourceFolder=self.sourceFolder)
        target.setFilenamePredicate(predicate)
        target.load()

        self.imageReader.read.assert_has_calls([
            call(self.sourceFolder, 'file.jpg'),
            call(self.sourceFolder, 'file3.jpg')
        ])
        self.assertEqual(len(self.imageReader.read.call_args_list), 2)