def test_attacked(self): """tests that it gives the right results with attacked set to true""" settings = {'attacked': True} ip = IndexedPiece() ip._analyses['noterest'] = self.NOTES actual = ip.get_data('active_voices', settings=settings) self.assertTrue(actual.equals(self.ATT_EXPECTED))
def test_show(self): """tests that the ``show_all`` argument works when True""" settings = {'show_all': True} ip = IndexedPiece() ip._analyses['noterest'] = self.NOTES actual = ip.get_data('active_voices', settings=settings) self.assertTrue(actual.equals(self.SHOW_EXPECTED))
def test_active(self): """tests that it gives the right results with no settings and that the get_data() method properly calls active_voices""" ip = IndexedPiece() ip._analyses['noterest'] = self.NOTES actual = ip.get_data('active_voices') self.assertTrue(actual.equals(self.EXPECTED))
def test_intervals_9(self): """same as test_8 *but* no quality""" # NB: the "expected" was hand-counted # TODO: change this into a WorkflowManager-using test when the "horizontal intervals" experiment is ready expected = pandas.read_csv(os.path.join(VIS_PATH, 'tests', 'expecteds', 'bwv77', 'A_horiz_ints_nq.csv'), comment='#', index_col=0, header=[0, 1], quotechar="'", dtype='object') setts = { 'quality': False, 'simple or compound': 'compound', 'horiz_attach_later': True } test_ip = IndexedPiece( os.path.join(VIS_PATH, 'tests', 'corpus', 'bwv77.mxl')) actual = test_ip.get_data( [noterest.NoteRestIndexer, interval.HorizontalIntervalIndexer], setts) actual = actual['interval.HorizontalIntervalIndexer'] self.assertEqual(4, len(actual.columns)) actual = pandas.DataFrame({ ('interval.HorizontalIntervalIndexer', '1'): actual['1'].dropna() }) self.assertDataFramesEqual(expected, actual)
def test_ngrams_1(self): # test that all-voice interval 2-grams work ind_piece = IndexedPiece(u"vis/tests/corpus/bwv2.xml") setts = {u"quality": False, u"simple": False} horiz_ints = ind_piece.get_data([noterest.NoteRestIndexer, interval.HorizontalIntervalIndexer], setts) vert_ints = ind_piece.get_data([noterest.NoteRestIndexer, interval.IntervalIndexer], setts) parts = [vert_ints[u"0,3"], vert_ints[u"1,3"], vert_ints[u"2,3"], horiz_ints[3]] setts[u"vertical"] = [0, 1, 2] setts[u"horizontal"] = [3] setts[u"mark singles"] = False setts[u"continuer"] = u"1" setts[u"n"] = 2 actual = ind_piece.get_data([ngram.NGramIndexer], setts, parts) self.assertEqual(1, len(actual)) actual = actual[0] expected = AllVoiceIntervalNGrams.series_maker(AllVoiceIntervalNGrams.twograms) self.assertSequenceEqual(list(expected.index), list(actual.index)) self.assertSequenceEqual(list(expected), list(actual))
def ngram_count(piece, settings, n): ngrams = [] ngram_freq = {} ind_piece = IndexedPiece(piece) the_score = music21.converter.parse(piece) the_notes = noterest.NoteRestIndexer(the_score).run() horiz_setts = settings # horiz-attach-later has to be true for the ngram indexer to work horiz_setts['horiz_attach_later'] = True horiz = interval.HorizontalIntervalIndexer(the_notes, horiz_setts).run() vert = interval.IntervalIndexer(the_notes, settings).run() intls = pandas.concat([horiz, vert], axis=1) parts = len(the_score.parts) # gets ngrams between all possible combinations of parts for x in range(parts): setts = { 'mark singles': False, 'continuer': '1', 'n': n, 'horizontal': [('interval.HorizontalIntervalIndexer', str(x))] } for i in range(x + 1, parts, 1): num = str(x) + ',' + str(i) setts['vertical'] = [('interval.IntervalIndexer', num)] ngram_test = ind_piece.get_data([ngram.NGramIndexer], setts, intls) ngrams.extend(ngram_test.values.tolist()) # count ngrams for my_ngram in ngrams: my_ngram = str(' '.join(my_ngram)) if 'Rest' in my_ngram: pass elif my_ngram in ngram_freq.keys(): ngram_freq[my_ngram] += 1 else: ngram_freq[my_ngram] = 1 return ngram_freq
def test_duration_indexer_3(self): # When there are a bunch of notes expected = TestDurationIndexer.make_series([(float(x), 1.0) for x in range(10)]) expected.name = 'Part_1' test_part = stream.Part() # add stuff to the test_part for i in range(10): add_me = note.Note('C4', quarterLength=1.0) add_me.offset = i test_part.append(add_me) ip = IndexedPiece() test_part = [test_part] ip._analyses['part_streams'] = test_part ip.metadata('parts', [expected.name]) actual = ip.get_data('duration').iloc[:, 0] self.assertTrue(actual.equals(expected))
def test_intervals_9(self): """same as test_8 *but* no quality""" # NB: the "expected" was hand-counted # TODO: change this into a WorkflowManager-using test when the "horizontal intervals" experiment is ready expected = pandas.read_csv(os.path.join(VIS_PATH, 'tests', 'expecteds', 'bwv77', 'A_horiz_ints_nq.csv'), comment='#', index_col=0, header=[0, 1], quotechar="'", dtype='object') setts = {'quality': False, 'simple or compound': 'compound', 'horiz_attach_later': True} test_ip = IndexedPiece(os.path.join(VIS_PATH, 'tests', 'corpus', 'bwv77.mxl')) actual = test_ip.get_data([noterest.NoteRestIndexer, interval.HorizontalIntervalIndexer], setts) actual = actual['interval.HorizontalIntervalIndexer'] self.assertEqual(4, len(actual.columns)) actual = pandas.DataFrame({('interval.HorizontalIntervalIndexer', '1'): actual['1'].dropna()}) self.assertDataFramesEqual(expected, actual)
def test_note_rest_indexer_2(self): # When the part has no Note or Rest objects in it. Really this is a test for the methods between # _get_part_streams() and _get_noterest(). expected = pandas.DataFrame({'Part 1': pandas.Series()}) test_part = stream.Part() # add stuff to the test_part for i in range(1000): add_me = clef.BassClef() add_me.offset = i test_part.append(add_me) add_me = bar.Barline() add_me.offset = i test_part.append(add_me) ip = IndexedPiece() ip._analyses['part_streams'] = [test_part] ip.metadata('parts', _find_part_names(ip._analyses['part_streams'])) actual = ip.get_data('noterest')['noterest.NoteRestIndexer'] self.assertTrue(actual.equals(expected))
class TestIndexedPieceA(TestCase): def setUp(self): self._pathname = u'test_path' self.ind_piece = IndexedPiece(self._pathname) def test_metadata(self): # access fields which are set by default pathname = self.ind_piece.metadata('pathname') self.assertEquals(self._pathname, pathname, "pathname has changed!") # assign a value to a valid field self.ind_piece.metadata('date', 2) value = self.ind_piece.metadata('date') self.assertEquals(2, value, "extracted metadata field doesn't match assigned value") # assign a value to an invalid field self.assertRaises(AttributeError, self.ind_piece.metadata, 'field', 2) # access an invalid value self.assertRaises(AttributeError, self.ind_piece.metadata, 'invalid_field') # try accessing keys with invalid types self.assertRaises(TypeError, self.ind_piece.metadata, 2) self.assertRaises(TypeError, self.ind_piece.metadata, []) self.assertRaises(TypeError, self.ind_piece.metadata, {}) def test_get_data_0(self): # try getting data for a non-Indexer, non-Experimenter class non_analyzer = Mock() self.assertRaises(TypeError, self.ind_piece.get_data, non_analyzer) def test_get_data_1(self): # get data for an Indexer requiring a Score mock_indexer_cls = type('MockIndexer', (Indexer,), {}) mock_indexer_cls.required_score_type = music21.stream.Part mock_indexer_cls.run = MagicMock() mock_indexer_cls.run.return_value = u'ahhh!' self.assertEquals(u'ahhh!', self.ind_piece.get_data([mock_indexer_cls])) mock_indexer_cls.run.assert_called_once_with() def test_get_data_2(self): # get data for an Indexer requiring other data mock_indexer_cls = type('MockIndexer', (Indexer,), {}) mock_init = MagicMock() mock_init.return_value = None mock_indexer_cls.__init__ = mock_init mock_indexer_cls.run = MagicMock() mock_indexer_cls.run.return_value = u'ahhh!' mock_indexer_cls.required_score_type = int self.assertEqual(u'ahhh!', self.ind_piece.get_data([mock_indexer_cls], data=[14])) mock_indexer_cls.run.assert_called_once_with() mock_init.assert_called_once_with([14], None) def test_get_data_3(self): # get data from a chained Indexer first_indexer_cls = type('MockIndexer', (Indexer,), {}) first_init = MagicMock() first_init.return_value = None first_indexer_cls.__init__ = first_init first_indexer_cls.run = MagicMock() first_indexer_cls.run.return_value = [14] first_indexer_cls.required_score_type = music21.stream.Part second_indexer_cls = type('MockIndexer', (Indexer,), {}) second_init = MagicMock() second_init.return_value = None second_indexer_cls.__init__ = second_init second_indexer_cls.run = MagicMock() second_indexer_cls.run.return_value = u'ahhh!' second_indexer_cls.required_score_type = int self.assertEqual(u'ahhh!', self.ind_piece.get_data([first_indexer_cls, second_indexer_cls])) first_init.assert_called_once_with([], None) second_init.assert_called_once_with(first_indexer_cls.run.return_value, None) first_indexer_cls.run.assert_called_once_with() second_indexer_cls.run.assert_called_once_with() def test_get_data_4(self): # chained Indexer plus settings first_indexer_cls = type('MockIndexer', (Indexer,), {}) first_init = MagicMock() first_init.return_value = None first_indexer_cls.__init__ = first_init first_indexer_cls.run = MagicMock() first_indexer_cls.run.return_value = [14] first_indexer_cls.required_score_type = music21.stream.Part second_indexer_cls = type('MockIndexer', (Indexer,), {}) second_init = MagicMock() second_init.return_value = None second_indexer_cls.__init__ = second_init second_indexer_cls.run = MagicMock() second_indexer_cls.run.return_value = u'ahhh!' second_indexer_cls.required_score_type = int settings_dict = {u'fake setting': u'so good!'} self.assertEqual(u'ahhh!', self.ind_piece.get_data([first_indexer_cls, second_indexer_cls], settings_dict)) first_init.assert_called_once_with([], settings_dict) second_init.assert_called_once_with(first_indexer_cls.run.return_value, settings_dict) first_indexer_cls.run.assert_called_once_with() second_indexer_cls.run.assert_called_once_with() def test_get_data_5(self): # get data from an Experimenter that requires an Indexer # (same as test 3, but second_indexer_cls is an Experimenter subclass) mock_indexer_cls = type('MockIndexer', (Indexer,), {}) mock_init = MagicMock() mock_init.return_value = None mock_indexer_cls.__init__ = mock_init mock_indexer_cls.run = MagicMock() mock_indexer_cls.run.return_value = [14] mock_indexer_cls.required_score_type = music21.stream.Part mock_experimenter_cls = type('MockIndexer', (Experimenter,), {}) exp_init = MagicMock() exp_init.return_value = None mock_experimenter_cls.__init__ = exp_init mock_experimenter_cls.run = MagicMock() mock_experimenter_cls.run.return_value = u'ahhh!' self.assertEqual(u'ahhh!', self.ind_piece.get_data([mock_indexer_cls, mock_experimenter_cls])) mock_init.assert_called_once_with([], None) exp_init.assert_called_once_with(mock_indexer_cls.run.return_value, None) mock_indexer_cls.run.assert_called_once_with() mock_experimenter_cls.run.assert_called_once_with() def test_get_data_6(self): # That get_data() complains when an Indexer expects the results of another Indexer but # doesn't get them. mock_indexer_cls = type('MockIndexer', (Indexer,), {}) mock_indexer_cls.required_score_type = pandas.Series self.assertRaises(RuntimeError, self.ind_piece.get_data, [mock_indexer_cls]) def test_get_data_7(self): # That get_data() complains when you call it with something that isn't either an Indexer # or Experimenter. self.assertRaises(TypeError, self.ind_piece.get_data, [TestIndexedPieceB]) def test_get_data_8(self): # That get_data() calls _get_note_rest_index() if asked for NoteRestIndexer. with patch.object(IndexedPiece, u'_get_note_rest_index') as mock_gnri: self.ind_piece.get_data([noterest.NoteRestIndexer]) mock_gnri.assert_called_once_with(known_opus=False) def test_get_data_9(self): # That get_data() calls _get_note_rest_index() if asked for NoteRestIndexer, and another # test Indexer is also called. This is a regression test to monitor a bug found after # implementing caching of NoteRestIndexer results. Also ensure that NoteRestIndexer is only # instantiated once with patch.object(IndexedPiece, u'_get_note_rest_index') as mock_gnri: mock_gnri.return_value = 42 with patch.object(IndexedPiece, u'_type_verifier') as mock_tv: # we'll mock _type_verifier() to avoid getting a TypeError when mock_nri_cls isn't # a proper subclass of Indexer expected = [400] mock_indexer_cls = type('MockIndexer', (Indexer,), {}) mock_indexer_cls.__init__ = MagicMock() mock_indexer_cls.__init__.return_value = None mock_indexer_cls.run = MagicMock() mock_indexer_cls.run.return_value = expected actual = self.ind_piece.get_data([noterest.NoteRestIndexer, mock_indexer_cls]) self.assertEqual(2, mock_tv.call_count) mock_tv.assert_has_calls([call([noterest.NoteRestIndexer, mock_indexer_cls]), call([mock_indexer_cls])]) mock_gnri.assert_called_once_with(known_opus=False) mock_indexer_cls.__init__.assert_called_once_with(mock_gnri.return_value, None) mock_indexer_cls.run.assert_called_once_with() self.assertEqual(expected, actual) def test_get_data_10(self): # That get_data() calls _get_note_rest_index() if asked for NoteRestIndexer. This is a # regression test to monitor a bug found after implementing caching of NoteRestIndexer # results. Also ensure that NoteRestIndexer is only instantiated once with patch.object(IndexedPiece, u'_get_note_rest_index') as mock_gnri: mock_gnri.return_value = 42 with patch.object(IndexedPiece, u'_type_verifier') as mock_tv: # we'll mock _type_verifier() to avoid getting a TypeError when mock_nri_cls isn't # a proper subclass of Indexer actual = self.ind_piece.get_data([noterest.NoteRestIndexer]) mock_tv.assert_called_once_with([noterest.NoteRestIndexer]) mock_gnri.assert_called_once_with(known_opus=False) self.assertEqual(mock_gnri.return_value, actual) def test_get_data_11(self): # That get_data() correctly passes its "known_opus" parameter to _get_note_rest_indexer() # and _import_score() with patch.object(IndexedPiece, u'_get_note_rest_index') as mock_gnri: self.ind_piece.get_data([noterest.NoteRestIndexer], known_opus='battery') mock_gnri.assert_called_once_with(known_opus='battery') with patch.object(IndexedPiece, u'_import_score') as mock_is: with patch.object(IndexedPiece, u'_type_verifier') as mock_tv: mock_ind = MagicMock() mock_ind.required_score_type = music21.stream.Part self.ind_piece.get_data([mock_ind], known_opus='horse') mock_is.assert_called_once_with(known_opus='horse') def test_get_data_12(self): # get data for an Experimenter requiring other data; this is test 2, slightly modified mock_experimenter_cls = type('MockExperimenter', (Experimenter,), {}) mock_experimenter_cls.__init__ = MagicMock(return_value=None) mock_experimenter_cls.run = MagicMock(return_value=u'ahhh!') prev_data= u'data from the previous analyzers' self.assertEqual(u'ahhh!', self.ind_piece.get_data([mock_experimenter_cls], {}, prev_data)) mock_experimenter_cls.run.assert_called_once_with() mock_experimenter_cls.__init__.assert_called_once_with(prev_data, {}) def test_type_verifier_1(self): # with an Indexer # pylint: disable=W0212 self.assertEqual(None, IndexedPiece._type_verifier([noterest.NoteRestIndexer])) def test_type_verifier_2(self): # with an Experimenter # pylint: disable=W0212 cls = type('TestExperimenter', (Experimenter,), {}) self.assertEqual(None, IndexedPiece._type_verifier([cls])) def test_type_verifier_3(self): # with another class # pylint: disable=W0212 cls = type('TestGarbage', (object,), {}) self.assertRaises(TypeError, IndexedPiece._type_verifier, [cls]) def test_type_verifier_4(self): # with a bunch of valid classes # pylint: disable=W0212 cls_1 = type('TestExperimenter1', (Experimenter,), {}) cls_2 = type('TestExperimenter2', (Experimenter,), {}) cls_3 = type('TestIndexer', (Indexer,), {}) self.assertEqual(None, IndexedPiece._type_verifier([cls_1, cls_2, cls_3])) def test_type_verifier_5(self): # with a bunch of valid, but one invalid, class # pylint: disable=W0212 cls_1 = type('TestExperimenter1', (Experimenter,), {}) cls_2 = type('TestIndexer', (Indexer,), {}) cls_3 = type('TestGarbage', (object,), {}) self.assertRaises(TypeError, IndexedPiece._type_verifier, [cls_1, cls_2, cls_3]) def test_get_nrindex_1(self): # pylint: disable=W0212 # That _get_note_rest_index() returns self._noterest_results if it's not None. self.ind_piece._noterest_results = 42 self.assertEqual(42, self.ind_piece._get_note_rest_index()) def test_get_nrindex_2(self): # pylint: disable=W0212 # That we run the NoteRestIndexer and store results in self._note_rest_results if is None. with patch(u'vis.models.indexed_piece.noterest.NoteRestIndexer') as mock_nri_cls: mock_nri = MagicMock(return_value=[14]) mock_nri.run = MagicMock() mock_nri.run.return_value = [14] mock_nri_cls.return_value = mock_nri expected = [14] actual = self.ind_piece._get_note_rest_index() mock_nri.run.assert_called_once_with() self.assertEqual(expected, actual) self.assertEqual(expected, self.ind_piece._noterest_results) def test_get_nrindex_3(self): # That _get_note_rest_index() just flat-out calls _import_score() when "known_opus" is True with patch.object(IndexedPiece, u'_import_score') as mock_is: with patch.object(noterest.NoteRestIndexer, u'run') as mock_nri: self.ind_piece._get_note_rest_index(known_opus=True) mock_is.assert_called_once_with(known_opus=True) self.assertEqual(0, mock_nri.call_count) def test_unicode_1(self): # __unicode__() without having imported yet # NB: adjusting _imported is the whole point of the test # pylint: disable=W0212 self.ind_piece._imported = False with patch(u'vis.models.indexed_piece.IndexedPiece.metadata') as mock_meta: mock_meta.return_value = u'42' expected = u'<IndexedPiece (42)>' actual = self.ind_piece.__unicode__() self.assertEqual(expected, actual) mock_meta.assert_called_once_with(u'pathname') def test_unicode_2(self): # __unicode__() with proper title and composer # NB: adjusting _imported is the whole point of the test # pylint: disable=W0212 self.ind_piece._imported = True with patch(u'vis.models.indexed_piece.IndexedPiece.metadata') as mock_meta: returns = [u'some ridiculous piece', u'a no-name composer'] def side_effect(*args): # NB: we need to accept "args" as a mock framework formality # pylint: disable=W0613 return returns.pop(0) mock_meta.side_effect = side_effect expected = u'<IndexedPiece (some ridiculous piece by a no-name composer)>' actual = self.ind_piece.__unicode__() self.assertEqual(expected, actual) expected_calls = [call(u'title'), call(u'composer')] self.assertSequenceEqual(expected_calls, mock_meta.call_args_list)
def test_with_data(self): """tests that it gives the right results with no settings and that the get_data() method properly calls active_voices""" ip = IndexedPiece() actual = ip.get_data('active_voices', data=self.NOTES) self.assertTrue(actual.equals(self.EXPECTED))
# the piece we'll analyze... currently Kyrie of Palestrina's Missa "Dies sanctificatus" print(u'\n\nLoading the piece and running the NoteRestIndexer...\n') #piece_path = u'vis/tests/corpus/Palestrina-Lhomme_arme_1582-Agnus_I.krn' piece_path = u'vis/tests/corpus/Kyrie.krn' #piece_path = u'vis/tests/corpus/bwv2.xml' #piece_path = u'/home/amor/Desktop/ELVIS_Meeting/J and P Lassus Files/Best duo score files/Lassus_3_Oculus.xml' the_piece = IndexedPiece(piece_path) # don't touch this (yet); it's settings required by DissonanceIndexer setts = {u'quality': True, 'simple or compound': u'simple'} # find the intervals print(u'\n\nRunning the IntervalIndexer...\n') intervals = the_piece.get_data([noterest.NoteRestIndexer, interval.IntervalIndexer], setts) horiz_intervals = the_piece.get_data([noterest.NoteRestIndexer, interval.HorizontalIntervalIndexer], setts) # find the dissonances print(u'\n\nRunning the DissonanceIndexer...\n') dissonances = the_piece.get_data([noterest.NoteRestIndexer, interval.IntervalIndexer, dissonance.DissonanceIndexer], setts) # get and display the output from the "beatStrength" indexer print(u'\n\nRunning the NoteBeatStrengthIndexer...\n') beat_strengths = the_piece.get_data([metre.NoteBeatStrengthIndexer], setts)
def build_fingerprint_matrices(self): # pathnames: List of paths to each piece for which a fingerprint matrix should be built # number_of_fingerprints: however many fingerprints you need interval_settings = self.interval_settings fingerprint_matrices = {} # Load pickled fingerprints if self.fp_pickle_path is not None: if os.path.isfile(self.fp_pickle_path): print "Found pickled fingerprints at '" + self.fp_pickle_path +"', importing..." with open(self.fp_pickle_path, 'rb') as fp_pickle: fingerprint_matrices = pickle.load(fp_pickle) else: print "Warning: was asked to look for pickled fingerprints at '" + self.fp_pickle_path +"'" print "Couldn't find any -- new pickle file will be created." number_of_fingerprints = self.number_of_fingerprints for path in self.pathnames: # Skip pickled fingerprints if os.path.basename(path) in fingerprint_matrices.keys(): continue # Setup for each piece #print("Indexing " + path) piece = IndexedPiece(path) piece_stream = music21.converter.parseFile(path) # LM: Get time signature and determine strong beats time_sigs = piece.get_data([metre.TimeSignatureIndexer]) # Assuming no time signature change in whole piece, assign offsets to strong beats if time_sigs['metre.TimeSignatureIndexer']['0'].iloc[0] == '6/8' or time_sigs['metre.TimeSignatureIndexer']['0'].iloc[0] == '9/8': strong_beat_offsets = 1.5 measures = 4 else: strong_beat_offsets = 1.0 measures = 4 # LM: Get total number of offsets numer, denom = time_sigs['metre.TimeSignatureIndexer']['0'].iloc[0].split('/') # Four bars worth of offsets, ignoring anacrusis... # Add an extra strong beat at end total_offsets = int(numer) * measures*4.0/int(denom) + strong_beat_offsets interval_settings['quarterLength'] = strong_beat_offsets interval_settings['intervalDistance'] = strong_beat_offsets interval_settings['subsection'] = (0.0, total_offsets) # LM: Build strong-interval frame strong_intervals = self.__build_strong_intervals(piece, interval_settings, strong_beat_offsets, total_offsets) # LM: Build weak-interval frame weak_intervals = self.__build_weak_intervals(piece, interval_settings, strong_beat_offsets, total_offsets) # LM: Assemble results # 1. Prepare strong_intervals -- had to change this due to change in representation... take off final column (start of new bar) strong_intervals = strong_intervals.T.iloc[:-1].T strong_intervals = self.__shift_matrix(strong_intervals) # Had to change this due to change in representation.... take off final row # strong_intervals = strong_intervals.iloc[:] # 2. Prepare weak_intervals: weak_intervals = weak_intervals.iloc[:] weak_intervals.index = my_range(strong_beat_offsets, strong_beat_offsets, total_offsets+strong_beat_offsets) # 3. Row of 0s --- added after discussion with Laura pertaining to fingerprint representation zeros = DataFrame(Series([0.0]*(len(weak_intervals)))) zeros.index = (my_range(strong_beat_offsets, strong_beat_offsets, total_offsets+strong_beat_offsets)) zeros = zeros.T # 4. Append fingerprint_frame = pandas.concat([weak_intervals.T, zeros, strong_intervals]) fingerprint_frame.index = (['w'] + fingerprint_frame.index.tolist()[1:]) #piece_stream.show('musicxml', 'MuseScore') # DataFrame(Series([0.0]*(len(weak_intervals)+1))).reindex(range(1, len(weak_intervals)+1)).T fingerprint_matrices[os.path.basename(path)]=fingerprint_frame number_of_fingerprints -= 1 if 0 == number_of_fingerprints: print "Max Number of Fingerprints Reached" break return fingerprint_matrices