def runTest(self, relative_root, recursive):
    """Tests the output for the given parameters."""
    root_dir = os.path.join(self.root_dir, relative_root)
    expected_filenames = self.expected_dir_midi_contents[relative_root]
    if recursive:
      for sub_dir in self.expected_sub_dirs[relative_root]:
        for filename in self.expected_dir_midi_contents[
            os.path.join(relative_root, sub_dir)]:
          expected_filenames.add(os.path.join(sub_dir, filename))

    with tempfile.NamedTemporaryFile(
        prefix='ConvertMidiDirToSequenesTest') as output_file:
      with note_sequence_io.NoteSequenceRecordWriter(
          output_file.name) as writer:
        convert_midi_dir_to_note_sequences.convert_directory(
            root_dir, '', writer, recursive)
      actual_filenames = set()
      for sequence in note_sequence_io.note_sequence_record_iterator(
          output_file.name):
        self.assertEquals(
            note_sequence_io.generate_id(sequence.filename,
                                         os.path.basename(relative_root),
                                         'midi'),
            sequence.id)
        self.assertEquals(os.path.basename(root_dir), sequence.collection_name)
        self.assertNotEquals(0, len(sequence.notes))
        actual_filenames.add(sequence.filename)

    self.assertEquals(expected_filenames, actual_filenames)
Esempio n. 2
0
def main(unused_argv):
    if not FLAGS.midi_dir:
        tf.logging.fatal("--midi_dir required")
    if not FLAGS.output_file:
        tf.logging.fatal("--output_file required")
    with note_sequence_io.NoteSequenceRecordWriter(
            FLAGS.output_file) as sequence_writer:
        sequences_written = convert_directory(FLAGS.midi_dir, '',
                                              sequence_writer, FLAGS.recursive)
        tf.logging.info("Wrote %d NoteSequence protos to '%s'",
                        sequences_written, FLAGS.output_file)
Esempio n. 3
0
  def testNoteSequenceRecordWriterAndIterator(self):
    sequences = []
    for i in xrange(4):
      sequence = music_pb2.NoteSequence()
      sequence.id = str(i)
      sequence.notes.add().pitch = i
      sequences.append(sequence)

    with tempfile.NamedTemporaryFile(prefix='NoteSequenceIoTest') as temp_file:
      with note_sequence_io.NoteSequenceRecordWriter(temp_file.name) as writer:
        for sequence in sequences:
          writer.write(sequence)

      for i, sequence in enumerate(
          note_sequence_io.note_sequence_record_iterator(temp_file.name)):
        self.assertEquals(sequence, sequences[i])
def main(unused_argv):
  if not FLAGS.midi_dir:
    tf.logging.fatal("--midi_dir required")
    return
  if not FLAGS.output_file:
    tf.logging.fatal("--output_file required")
    return

  FLAGS.midi_dir = os.path.expanduser(FLAGS.midi_dir)
  FLAGS.output_file = os.path.expanduser(FLAGS.output_file)

  if not os.path.exists(os.path.dirname(FLAGS.output_file)):
    os.makedirs(os.path.dirname(FLAGS.output_file))

  with note_sequence_io.NoteSequenceRecordWriter(
      FLAGS.output_file) as sequence_writer:
    sequences_written = convert_directory(FLAGS.midi_dir, '', sequence_writer,
                                          FLAGS.recursive)
    tf.logging.info("Wrote %d NoteSequence protos to '%s'", sequences_written,
                    FLAGS.output_file)