Switch references from magenta.music to note_seq library.

PiperOrigin-RevId: 316875465
Change-Id: I0b9ae2ad2c05e8e5d5a8a12879283a39c029cbd8

magenta/__init__.py

@@ -30,32 +30,6 @@
 import magenta.common.state_util
 import magenta.common.testing_lib
 import magenta.common.tf_utils
-import magenta.music.abc_parser
-import magenta.music.audio_io
-import magenta.music.chord_symbols_lib
-import magenta.music.chords_encoder_decoder
-import magenta.music.chords_lib
-import magenta.music.constants
-import magenta.music.drums_encoder_decoder
-import magenta.music.drums_lib
-import magenta.music.encoder_decoder
-import magenta.music.events_lib
-import magenta.music.lead_sheets_lib
-import magenta.music.melodies_lib
-import magenta.music.melody_encoder_decoder
-import magenta.music.midi_io
-import magenta.music.midi_synth
-import magenta.music.musicxml_parser
-import magenta.music.musicxml_reader
-import magenta.music.notebook_utils
-import magenta.music.performance_encoder_decoder
-import magenta.music.performance_lib
-import magenta.music.pianoroll_encoder_decoder
-import magenta.music.pianoroll_lib
-import magenta.music.protobuf.generator_pb2
-import magenta.music.protobuf.music_pb2
-import magenta.music.sequences_lib
-import magenta.music.testing_lib
 import magenta.pipelines.dag_pipeline
 import magenta.pipelines.drum_pipelines
 import magenta.pipelines.lead_sheet_pipelines
@@ -65,5 +39,4 @@
 import magenta.pipelines.pipelines_common
 import magenta.pipelines.statistics
 import magenta.version
-
 from magenta.version import __version__

magenta/interfaces/midi/midi_hub.py

@@ -24,8 +24,8 @@
 import time
 
 from magenta.common import concurrency
-from magenta.music.protobuf import music_pb2
 import mido
+from note_seq.protobuf import music_pb2
 import tensorflow.compat.v1 as tf
 
 _DEFAULT_METRONOME_TICK_DURATION = 0.05

magenta/interfaces/midi/midi_hub_test.py

@@ -21,9 +21,9 @@
 
 from magenta.common import concurrency
 from magenta.interfaces.midi import midi_hub
-from magenta.music import testing_lib
-from magenta.music.protobuf import music_pb2
 import mido
+from note_seq import testing_lib
+from note_seq.protobuf import music_pb2
 import tensorflow.compat.v1 as tf
 
 Note = collections.namedtuple('Note', ['pitch', 'velocity', 'start', 'end'])

magenta/interfaces/midi/midi_interaction.py

@@ -18,9 +18,9 @@
 import threading
 import time
 
-import magenta
-from magenta.music.protobuf import generator_pb2
-from magenta.music.protobuf import music_pb2
+import note_seq
+from note_seq.protobuf import generator_pb2
+from note_seq.protobuf import music_pb2
 import tensorflow.compat.v1 as tf
 
 
@@ -344,8 +344,9 @@ def _generate(self, input_sequence, zero_time, response_start_time,
     tf.logging.debug('Generator Options: %s', generator_options)
     response_sequence = self._sequence_generator.generate(
         adjust_sequence_times(input_sequence, -zero_time), generator_options)
-    response_sequence = magenta.music.trim_note_sequence(
-        response_sequence, response_start_time, response_end_time)
+    response_sequence = note_seq.trim_note_sequence(response_sequence,
+                                                    response_start_time,
+                                                    response_end_time)
     return adjust_sequence_times(response_sequence, zero_time)
 
   def run(self):

magenta/models/drums_rnn/README.md

@@ -116,7 +116,7 @@ drums_rnn_generate \
 
 ### Creating a Bundle File
 
-The [bundle format](/magenta/music/protobuf/generator.proto)
+The [bundle format](https://github.com/magenta/note-seq/blob/master/note_seq/protobuf/generator.proto)
 is a convenient way of combining the model checkpoint, metagraph, and
 some metadata about the model into a single file.
 

magenta/models/drums_rnn/drums_rnn_create_dataset_test.py

@@ -18,10 +18,11 @@
 from magenta.contrib import training as contrib_training
 from magenta.models.drums_rnn import drums_rnn_pipeline
 from magenta.models.shared import events_rnn_model
-from magenta.music.protobuf import music_pb2
 from magenta.pipelines import drum_pipelines
 from magenta.pipelines import note_sequence_pipelines
 from magenta.pipelines import pipelines_common
+import note_seq
+import note_seq.testing_lib
 import tensorflow.compat.v1 as tf
 
 tf.disable_v2_behavior()
@@ -35,31 +36,30 @@ def setUp(self):
     super().setUp()
     self.config = events_rnn_model.EventSequenceRnnConfig(
         None,
-        magenta.music.OneHotEventSequenceEncoderDecoder(
-            magenta.music.MultiDrumOneHotEncoding()),
-        contrib_training.HParams())
+        note_seq.OneHotEventSequenceEncoderDecoder(
+            note_seq.MultiDrumOneHotEncoding()), contrib_training.HParams())
 
   def testDrumsRNNPipeline(self):
     note_sequence = magenta.common.testing_lib.parse_test_proto(
-        music_pb2.NoteSequence,
+        note_seq.NoteSequence,
         """
         time_signatures: {
           numerator: 4
           denominator: 4}
         tempos: {
           qpm: 120}""")
-    magenta.music.testing_lib.add_track_to_sequence(
-        note_sequence, 0,
-        [(36, 100, 0.00, 2.0), (40, 55, 2.1, 5.0), (44, 80, 3.6, 5.0),
-         (41, 45, 5.1, 8.0), (64, 100, 6.6, 10.0), (55, 120, 8.1, 11.0),
-         (39, 110, 9.6, 9.7), (53, 99, 11.1, 14.1), (51, 40, 12.6, 13.0),
-         (55, 100, 14.1, 15.0), (54, 90, 15.6, 17.0), (60, 100, 17.1, 18.0)],
+    note_seq.testing_lib.add_track_to_sequence(
+        note_sequence,
+        0, [(36, 100, 0.00, 2.0), (40, 55, 2.1, 5.0), (44, 80, 3.6, 5.0),
+            (41, 45, 5.1, 8.0), (64, 100, 6.6, 10.0), (55, 120, 8.1, 11.0),
+            (39, 110, 9.6, 9.7), (53, 99, 11.1, 14.1), (51, 40, 12.6, 13.0),
+            (55, 100, 14.1, 15.0), (54, 90, 15.6, 17.0), (60, 100, 17.1, 18.0)],
         is_drum=True)
 
     quantizer = note_sequence_pipelines.Quantizer(steps_per_quarter=4)
     drums_extractor = drum_pipelines.DrumsExtractor(min_bars=7, gap_bars=1.0)
-    one_hot_encoding = magenta.music.OneHotEventSequenceEncoderDecoder(
-        magenta.music.MultiDrumOneHotEncoding())
+    one_hot_encoding = note_seq.OneHotEventSequenceEncoderDecoder(
+        note_seq.MultiDrumOneHotEncoding())
     quantized = quantizer.transform(note_sequence)[0]
     drums = drums_extractor.transform(quantized)[0]
     one_hot = pipelines_common.make_sequence_example(

magenta/models/drums_rnn/drums_rnn_generate.py

@@ -17,23 +17,18 @@
 
 Uses flags to define operation.
 """
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
 import ast
 import os
 import time
 
-import magenta
 from magenta.models.drums_rnn import drums_rnn_config_flags
 from magenta.models.drums_rnn import drums_rnn_model
 from magenta.models.drums_rnn import drums_rnn_sequence_generator
 from magenta.models.shared import sequence_generator
 from magenta.models.shared import sequence_generator_bundle
-from magenta.music.protobuf import generator_pb2
-from magenta.music.protobuf import music_pb2
+import note_seq
+from note_seq.protobuf import generator_pb2
+from note_seq.protobuf import music_pb2
 import tensorflow.compat.v1 as tf
 
 FLAGS = tf.app.flags.FLAGS
@@ -156,20 +151,20 @@ def run_with_flags(generator):
     tf.gfile.MakeDirs(FLAGS.output_dir)
 
   primer_sequence = None
-  qpm = FLAGS.qpm if FLAGS.qpm else magenta.music.DEFAULT_QUARTERS_PER_MINUTE
+  qpm = FLAGS.qpm if FLAGS.qpm else note_seq.DEFAULT_QUARTERS_PER_MINUTE
   if FLAGS.primer_drums:
-    primer_drums = magenta.music.DrumTrack(
-        [frozenset(pitches)
-         for pitches in ast.literal_eval(FLAGS.primer_drums)])
+    primer_drums = note_seq.DrumTrack([
+        frozenset(pitches) for pitches in ast.literal_eval(FLAGS.primer_drums)
+    ])
     primer_sequence = primer_drums.to_sequence(qpm=qpm)
   elif primer_midi:
-    primer_sequence = magenta.music.midi_file_to_sequence_proto(primer_midi)
+    primer_sequence = note_seq.midi_file_to_sequence_proto(primer_midi)
     if primer_sequence.tempos and primer_sequence.tempos[0].qpm:
       qpm = primer_sequence.tempos[0].qpm
   else:
     tf.logging.warning(
         'No priming sequence specified. Defaulting to a single bass drum hit.')
-    primer_drums = magenta.music.DrumTrack([frozenset([36])])
+    primer_drums = note_seq.DrumTrack([frozenset([36])])
     primer_sequence = primer_drums.to_sequence(qpm=qpm)
 
   # Derive the total number of seconds to generate based on the QPM of the
@@ -222,7 +217,7 @@ def run_with_flags(generator):
 
     midi_filename = '%s_%s.mid' % (date_and_time, str(i + 1).zfill(digits))
     midi_path = os.path.join(FLAGS.output_dir, midi_filename)
-    magenta.music.sequence_proto_to_midi_file(generated_sequence, midi_path)
+    note_seq.sequence_proto_to_midi_file(generated_sequence, midi_path)
 
   tf.logging.info('Wrote %d MIDI files to %s',
                   FLAGS.num_outputs, FLAGS.output_dir)

magenta/models/drums_rnn/drums_rnn_model.py

@@ -15,14 +15,10 @@
 # Lint as: python3
 """Drums RNN model."""
 
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import magenta
 from magenta.contrib import training as contrib_training
 from magenta.models.shared import events_rnn_model
-import magenta.music as mm
+import note_seq
+from note_seq.protobuf import generator_pb2
 
 
 class DrumsRnnModel(events_rnn_model.EventSequenceRnnModel):
@@ -68,13 +64,13 @@ def drum_track_log_likelihood(self, drums):
 default_configs = {
     'one_drum':
         events_rnn_model.EventSequenceRnnConfig(
-            magenta.music.protobuf.generator_pb2.GeneratorDetails(
+            generator_pb2.GeneratorDetails(
                 id='one_drum', description='Drums RNN with 2-state encoding.'),
-            magenta.music.OneHotEventSequenceEncoderDecoder(
-                magenta.music.MultiDrumOneHotEncoding(
+            note_seq.OneHotEventSequenceEncoderDecoder(
+                note_seq.MultiDrumOneHotEncoding(
                     [[39] +  # use hand clap as default when decoding
-                     list(range(mm.MIN_MIDI_PITCH, 39)) +
-                     list(range(39, mm.MAX_MIDI_PITCH + 1))])),
+                     list(range(note_seq.MIN_MIDI_PITCH, 39)) +
+                     list(range(39, note_seq.MAX_MIDI_PITCH + 1))])),
             contrib_training.HParams(
                 batch_size=128,
                 rnn_layer_sizes=[128, 128],
@@ -84,12 +80,12 @@ def drum_track_log_likelihood(self, drums):
             steps_per_quarter=2),
     'drum_kit':
         events_rnn_model.EventSequenceRnnConfig(
-            magenta.music.protobuf.generator_pb2.GeneratorDetails(
+            generator_pb2.GeneratorDetails(
                 id='drum_kit',
                 description='Drums RNN with multiple drums and binary counters.'
             ),
-            magenta.music.LookbackEventSequenceEncoderDecoder(
-                magenta.music.MultiDrumOneHotEncoding(),
+            note_seq.LookbackEventSequenceEncoderDecoder(
+                note_seq.MultiDrumOneHotEncoding(),
                 lookback_distances=[],
                 binary_counter_bits=6),
             contrib_training.HParams(

magenta/models/drums_rnn/drums_rnn_pipeline.py

@@ -14,13 +14,12 @@
 
 """Pipeline to create DrumsRNN dataset."""
 
-import magenta
-from magenta.music.protobuf import music_pb2
 from magenta.pipelines import dag_pipeline
 from magenta.pipelines import drum_pipelines
 from magenta.pipelines import event_sequence_pipeline
 from magenta.pipelines import note_sequence_pipelines
 from magenta.pipelines import pipelines_common
+import note_seq
 
 
 def get_pipeline(config, eval_ratio):
@@ -34,10 +33,10 @@ def get_pipeline(config, eval_ratio):
     A pipeline.Pipeline instance.
   """
   partitioner = pipelines_common.RandomPartition(
-      music_pb2.NoteSequence,
+      note_seq.NoteSequence,
       ['eval_drum_tracks', 'training_drum_tracks'],
       [eval_ratio])
-  dag = {partitioner: dag_pipeline.DagInput(music_pb2.NoteSequence)}
+  dag = {partitioner: dag_pipeline.DagInput(note_seq.NoteSequence)}
 
   for mode in ['eval', 'training']:
     time_change_splitter = note_sequence_pipelines.TimeChangeSplitter(
@@ -47,7 +46,8 @@ def get_pipeline(config, eval_ratio):
     drums_extractor = drum_pipelines.DrumsExtractor(
         min_bars=7, max_steps=512, gap_bars=1.0, name='DrumsExtractor_' + mode)
     encoder_pipeline = event_sequence_pipeline.EncoderPipeline(
-        magenta.music.DrumTrack, config.encoder_decoder,
+        note_seq.DrumTrack,
+        config.encoder_decoder,
         name='EncoderPipeline_' + mode)
 
     dag[time_change_splitter] = partitioner[mode + '_drum_tracks']

magenta/models/drums_rnn/drums_rnn_sequence_generator.py

@@ -18,8 +18,8 @@
 
 from magenta.models.drums_rnn import drums_rnn_model
 from magenta.models.shared import sequence_generator
-import magenta.music as mm
 from magenta.pipelines import drum_pipelines
+import note_seq
 
 
 class DrumsRnnSequenceGenerator(sequence_generator.BaseSequenceGenerator):
@@ -56,16 +56,17 @@ def _generate(self, input_sequence, generator_options):
     if input_sequence and input_sequence.tempos:
       qpm = input_sequence.tempos[0].qpm
     else:
-      qpm = mm.DEFAULT_QUARTERS_PER_MINUTE
-    steps_per_second = mm.steps_per_quarter_to_steps_per_second(
+      qpm = note_seq.DEFAULT_QUARTERS_PER_MINUTE
+    steps_per_second = note_seq.steps_per_quarter_to_steps_per_second(
         self.steps_per_quarter, qpm)
 
     generate_section = generator_options.generate_sections[0]
     if generator_options.input_sections:
       input_section = generator_options.input_sections[0]
-      primer_sequence = mm.trim_note_sequence(
-          input_sequence, input_section.start_time, input_section.end_time)
-      input_start_step = mm.quantize_to_step(
+      primer_sequence = note_seq.trim_note_sequence(input_sequence,
+                                                    input_section.start_time,
+                                                    input_section.end_time)
+      input_start_step = note_seq.quantize_to_step(
           input_section.start_time, steps_per_second, quantize_cutoff=0.0)
     else:
       primer_sequence = input_sequence
@@ -83,20 +84,20 @@ def _generate(self, input_sequence, generator_options):
           (generate_section.start_time, last_end_time))
 
     # Quantize the priming sequence.
-    quantized_sequence = mm.quantize_note_sequence(
+    quantized_sequence = note_seq.quantize_note_sequence(
         primer_sequence, self.steps_per_quarter)
     # Setting gap_bars to infinite ensures that the entire input will be used.
     extracted_drum_tracks, _ = drum_pipelines.extract_drum_tracks(
         quantized_sequence, search_start_step=input_start_step, min_bars=0,
         gap_bars=float('inf'), ignore_is_drum=True)
     assert len(extracted_drum_tracks) <= 1
 
-    start_step = mm.quantize_to_step(
+    start_step = note_seq.quantize_to_step(
         generate_section.start_time, steps_per_second, quantize_cutoff=0.0)
     # Note that when quantizing end_step, we set quantize_cutoff to 1.0 so it
     # always rounds down. This avoids generating a sequence that ends at 5.0
     # seconds when the requested end time is 4.99.
-    end_step = mm.quantize_to_step(
+    end_step = note_seq.quantize_to_step(
         generate_section.end_time, steps_per_second, quantize_cutoff=1.0)
 
     if extracted_drum_tracks and extracted_drum_tracks[0]:
@@ -106,11 +107,11 @@ def _generate(self, input_sequence, generator_options):
       # starts 1 step before the request start_step. This will result in 1 step
       # of silence when the drum track is extended below.
       steps_per_bar = int(
-          mm.steps_per_bar_in_quantized_sequence(quantized_sequence))
-      drums = mm.DrumTrack([],
-                           start_step=max(0, start_step - 1),
-                           steps_per_bar=steps_per_bar,
-                           steps_per_quarter=self.steps_per_quarter)
+          note_seq.steps_per_bar_in_quantized_sequence(quantized_sequence))
+      drums = note_seq.DrumTrack([],
+                                 start_step=max(0, start_step - 1),
+                                 steps_per_bar=steps_per_bar,
+                                 steps_per_quarter=self.steps_per_quarter)
 
     # Ensure that the drum track extends up to the step we want to start
     # generating.

magenta/models/gansynth/lib/generate_util.py

@@ -16,8 +16,8 @@
 """Helper functions for generating sounds.
 """
 
-from magenta import music as mm
 from magenta.models.gansynth.lib import util
+import note_seq
 import numpy as np
 import scipy.io.wavfile as wavfile
 
@@ -36,7 +36,7 @@ def slerp(p0, p1, t):
 def load_midi(midi_path, min_pitch=36, max_pitch=84):
   """Load midi as a notesequence."""
   midi_path = util.expand_path(midi_path)
-  ns = mm.midi_file_to_sequence_proto(midi_path)
+  ns = note_seq.midi_file_to_sequence_proto(midi_path)
   pitches = np.array([n.pitch for n in ns.notes])
   velocities = np.array([n.velocity for n in ns.notes])
   start_times = np.array([n.start_time for n in ns.notes])