Merge branch 'master' into feature/pytest

Paul Brossier committed 8 years ago

Commit 568fc602 parents a9e3bd0 bc1ed6315 files · +236 −170Browse files

Showing the changes to python (10 of 15 files). Show all

Unified · Split

10 files

python/demos/demo_filter.py +6 −4
python/demos/demo_filterbank.py +31 −17
python/demos/demo_source_simple.py +10 −6
python/ext/py-sink.c +1 −1
python/ext/py-source.c +3 −3
python/lib/aubio/__init__.py +1 −0
python/lib/aubio/cmd.py +65 −31
python/lib/aubio/cut.py +29 −49
python/lib/aubio/midiconv.py +17 −12
python/lib/aubio/slicing.py +10 −11

 import os.path
 import aubio
 def apply_filter(path, target):
     # open input file, get its samplerate
     s = aubio.source(path)
         # count frames read
         total_frames += read
         # end of file reached
-        if read < s.hop_size: break
+        if read < s.hop_size:
+            break
     # print some info
     duration = total_frames / float(samplerate)
     input_str = "input: {:s} ({:.2f} s, {:d} Hz)"
     output_str = "output: {:s}, A-weighting filtered ({:d} frames total)"
-    print (input_str.format(s.uri, duration, samplerate))
+    print(input_str.format(s.uri, duration, samplerate))
-    print (output_str.format(o.uri, total_frames))
+    print(output_str.format(o.uri, total_frames))
 if __name__ == '__main__':
     usage = "{:s} <input_file> [output_file]".format(sys.argv[0])
     if not 1 < len(sys.argv) < 4:
-        print (usage)
+        print(usage)
         sys.exit(1)
     if len(sys.argv) < 3:
         input_path = sys.argv[1]

python/demos/demo_filterbank.py+31−17

@@ -1,30 +1,44 @@
1	#! /usr/bin/env python	1	#! /usr/bin/env python
2		2
3	from aubio import filterbank, fvec	3	"""Create a filterbank from a list of frequencies.
4	from pylab import loglog, show, xlim, ylim, xlabel, ylabel, title
5	from numpy import vstack, arange
6		4
7	win_s = 2048	5	This demo uses `aubio.filterbank.set_triangle_bands` to build a set of
		6	triangular filters from a list of frequencies.
		7
		8	The filterbank coefficients are then modified before being displayed."""
		9
		10	import aubio
		11	import numpy as np
		12	import matplotlib.pyplot as plt
		13
		14	# sampling rate and size of the fft
8	samplerate = 48000	15	samplerate = 48000
		16	win_s = 2048
9		17
		18	# define a list of custom frequency
10	freq_list = [60, 80, 200, 400, 800, 1600, 3200, 6400, 12800, 24000]	19	freq_list = [60, 80, 200, 400, 800, 1600, 3200, 6400, 12800, 24000]
		20	# number of filters to create
11	n_filters = len(freq_list) - 2	21	n_filters = len(freq_list) - 2
12		22
13	f = filterbank(n_filters, win_s)	23	# create a new filterbank
14	freqs = fvec(freq_list)	24	f = aubio.filterbank(n_filters, win_s)
		25	freqs = aubio.fvec(freq_list)
15	f.set_triangle_bands(freqs, samplerate)	26	f.set_triangle_bands(freqs, samplerate)
16		27
		28	# get the coefficients from the filterbank
17	coeffs = f.get_coeffs()	29	coeffs = f.get_coeffs()
18	coeffs[4] *= 5.	30	# apply a gain to fifth band
19		31	coeffs[4] *= 6.
		32	# load the modified coeffs into the filterbank
20	f.set_coeffs(coeffs)	33	f.set_coeffs(coeffs)
21		34
22	times = vstack([arange(win_s // 2 + 1) * samplerate / win_s] * n_filters)	35	# display the band gains in a loglog plot
23	title('Bank of filters built using a simple list of boundaries\nThe middle band has been amplified by 2.')	36	freqs = np.vstack([np.arange(win_s // 2 + 1) * samplerate / win_s] * n_filters)
24	loglog(times.T, f.get_coeffs().T, '.-')	37	plt.title('filterbank built from a list of frequencies\n'
25	xlim([50, samplerate/2])	38	'The 5th band has been amplified by a factor 6.')
26	ylim([1.0e-6, 2.0e-2])	39	plt.loglog(freqs.T, f.get_coeffs().T, '.-')
27	xlabel('log frequency (Hz)')	40	plt.xlim([50, samplerate/2])
28	ylabel('log amplitude')	41	plt.ylim([1.0e-6, 2.0e-2])
29		42	plt.xlabel('log frequency (Hz)')
30	show()	43	plt.ylabel('log amplitude')
		44	plt.show()

python/demos/demo_source_simple.py+10−6

 #! /usr/bin/env python
+"""A simple example using aubio.source."""
 import sys
 import aubio
-samplerate = 0 # use original source samplerate
+samplerate = 0  # use original source samplerate
-hop_size = 256 # number of frames to read in one block
+hop_size = 256  # number of frames to read in one block
 src = aubio.source(sys.argv[1], samplerate, hop_size)
 total_frames = 0
 while True:
-    samples, read = src()     # read hop_size new samples from source
+    samples, read = src()  # read hop_size new samples from source
-    total_frames += read      # increment total number of frames
+    total_frames += read   # increment total number of frames
-    if read < hop_size: break # end of file reached
+    if read < hop_size:    # end of file reached
+        break
 fmt_string = "read {:d} frames at {:d}Hz from {:s}"
-print (fmt_string.format(total_frames, src.samplerate, src.uri))
+print(fmt_string.format(total_frames, src.samplerate, src.uri))

python/ext/py-sink.c+1−1

@@ -14,7 +14,7 @@ typedef struct · 13 unmodified lines
14	static char Py_sink_doc[] = ""	14	static char Py_sink_doc[] = ""
15	"sink(path, samplerate=44100, channels=1)\n"	15	"sink(path, samplerate=44100, channels=1)\n"
16	"\n"	16	"\n"
17	"Open `path` to write a WAV file.\n"	17	"Write audio samples to file.\n"
18	"\n"	18	"\n"
19	"Parameters\n"	19	"Parameters\n"
20	"----------\n"	20	"----------\n"

python/ext/py-source.c+3−3

@@ -18,7 +18,7 @@ typedef struct · 17 unmodified lines
18	static char Py_source_doc[] = ""	18	static char Py_source_doc[] = ""
19	"source(path, samplerate=0, hop_size=512, channels=0)\n"	19	"source(path, samplerate=0, hop_size=512, channels=0)\n"
20	"\n"	20	"\n"
21	"Create a new source, opening the given pathname for reading.\n"	21	"Read audio samples from a media file.\n"
22	"\n"	22	"\n"
23	"`source` open the file specified in `path` and creates a callable\n"	23	"`source` open the file specified in `path` and creates a callable\n"
24	"returning `hop_size` new audio samples at each invocation.\n"	24	"returning `hop_size` new audio samples at each invocation.\n"
@@ -247,7 +247,7 @@ static char Py_source_do_doc[] = "" · 222 unmodified lines
247	"\n"	247	"\n"
248	"Returns\n"	248	"Returns\n"
249	"-------\n"	249	"-------\n"
250	"samples : numpy.ndarray, shape `(hop_size,)`, dtype aubio.float_type\n"	250	"samples : numpy.ndarray\n"
251	" `fvec` of size `hop_size` containing the new samples.\n"	251	" `fvec` of size `hop_size` containing the new samples.\n"
252	"read : int\n"	252	"read : int\n"
253	" Number of samples read from the source, equals to `hop_size`\n"	253	" Number of samples read from the source, equals to `hop_size`\n"
@@ -283,7 +283,7 @@ static char Py_source_do_multi_doc[] = "" · 29 unmodified lines
283	"\n"	283	"\n"
284	"Returns\n"	284	"Returns\n"
285	"-------\n"	285	"-------\n"
286	"samples : np.ndarray([hop_size, channels], dtype=aubio.float_type)\n"	286	"samples : numpy.ndarray\n"
287	" NumPy array of shape `(hop_size, channels)` containing the new\n"	287	" NumPy array of shape `(hop_size, channels)` containing the new\n"
288	" audio samples.\n"	288	" audio samples.\n"
289	"read : int\n"	289	"read : int\n"

python/lib/aubio/__init__.py+1−0

@@ -29,6 +29,7 @@ from ._aubio import * · 28 unmodified lines
29	from .midiconv import *	29	from .midiconv import *
30	from .slicing import *	30	from .slicing import *
31		31
		32
32	class fvec(numpy.ndarray):	33	class fvec(numpy.ndarray):
33	"""fvec(input_arg=1024)	34	"""fvec(input_arg=1024)
34	A vector holding float samples.	35	A vector holding float samples.

python/lib/aubio/cmd.py+65−31

 import sys
 import argparse
+import warnings
 import aubio
 def aubio_parser():
                 help="samplerate at which the file should be represented")
     def add_verbose_help(self):
-        self.add_argument("-v","--verbose",
+        self.add_argument("-v", "--verbose",
                 action="count", dest="verbose", default=1,
                 help="make lots of noise [default]")
-        self.add_argument("-q","--quiet",
+        self.add_argument("-q", "--quiet",
                 action="store_const", dest="verbose", const=0,
                 help="be quiet")
         self.add_hop_size(hop_size=hop_size)
     def add_buf_size(self, buf_size=512):
-        self.add_argument("-B","--bufsize",
+        self.add_argument("-B", "--bufsize",
                 action="store", dest="buf_size", default=buf_size,
                 metavar = "<size>", type=int,
                 help="buffer size [default=%d]" % buf_size)
     def add_hop_size(self, hop_size=256):
-        self.add_argument("-H","--hopsize",
+        self.add_argument("-H", "--hopsize",
                 metavar = "<size>", type=int,
                 action="store", dest="hop_size", default=hop_size,
                 help="overlap size [default=%d]" % hop_size)
     def add_method(self, method='default', helpstr='method'):
-        self.add_argument("-m","--method",
+        self.add_argument("-m", "--method",
                 metavar = "<method>", type=str,
                 action="store", dest="method", default=method,
                 help="%s [default=%s]" % (helpstr, method))
     def add_threshold(self, default=None):
-        self.add_argument("-t","--threshold",
+        self.add_argument("-t", "--threshold",
                 metavar = "<threshold>", type=float,
                 action="store", dest="threshold", default=default,
                 help="threshold [default=%s]" % default)
                  help=helpstr)
     def add_slicer_options(self):
-        self.add_argument("-o","--output", type = str,
+        self.add_argument("-o", "--output", type = str,
                 metavar = "<outputdir>",
                 action="store", dest="output_directory", default=None,
-                help="specify path where slices of the original file should be created")
+                help="specify path where slices of the original file should"
+                " be created")
         self.add_argument("--cut-until-nsamples", type = int,
                 metavar = "<samples>",
                 action = "store", dest = "cut_until_nsamples", default = None,
-                help="how many extra samples should be added at the end of each slice")
+                help="how many extra samples should be added at the end of"
+                " each slice")
         self.add_argument("--cut-every-nslices", type = int,
                 metavar = "<samples>",
                 action = "store", dest = "cut_every_nslices", default = None,
         self.add_argument("--cut-until-nslices", type = int,
                 metavar = "<slices>",
                 action = "store", dest = "cut_until_nslices", default = None,
-                help="how many extra slices should be added at the end of each slice")
+                help="how many extra slices should be added at the end of"
+                " each slice")
         self.add_argument("--create-first",
                 action = "store_true", dest = "create_first", default = False,
                 help="always include first slice")
             self.time2string = timefunc(args.time_format)
         if args.verbose > 2 and hasattr(self, 'options'):
             name = type(self).__name__.split('_')[1]
-            optstr = ' '.join(['running', name, 'with options', repr(self.options), '\n'])
+            optstr = ' '.join(['running', name, 'with options',
+                repr(self.options), '\n'])
             sys.stderr.write(optstr)
     def flush(self, frames_read, samplerate):
         # optionally called at the end of process
     def parse_options(self, args, valid_opts):
         # get any valid options found in a dictionnary of arguments
-        options = {k :v for k,v in vars(args).items() if k in valid_opts}
+        options = {k: v for k, v in vars(args).items() if k in valid_opts}
         self.options = options
     def remap_pvoc_options(self, options):
         if len(self.beat_locations) < 2:
             outstr = "unknown bpm"
         else:
-            bpms = 60./ np.diff(self.beat_locations)
+            bpms = 60. / np.diff(self.beat_locations)
             median_bpm = np.mean(bpms)
             if len(self.beat_locations) < 10:
                 outstr = "%.2f bpm (uncertain)" % median_bpm
     def __call__(self, block):
         return self.notes(block)
     def repr_res(self, res, frames_read, samplerate):
-        if res[2] != 0: # note off
+        if res[2] != 0:  # note off
             fmt_out = self.time2string(frames_read, samplerate)
             sys.stdout.write(fmt_out + '\n')
-        if res[0] != 0: # note on
+        if res[0] != 0:  # note on
             lastmidi = res[0]
             fmt_out = "%f\t" % lastmidi
             fmt_out += self.time2string(frames_read, samplerate)
-            sys.stdout.write(fmt_out) # + '\t')
+            sys.stdout.write(fmt_out)  # + '\t')
     def flush(self, frames_read, samplerate):
         eof = self.time2string(frames_read, samplerate)
         sys.stdout.write(eof + '\n')
         if aubio.silence_detection(block, self.silence) == 1:
             if self.wassilence != 1:
                 self.wassilence = 1
-                return 2 # newly found silence
+                return 2   # newly found silence
-            return 1 # silence again
+            return 1       # silence again
         else:
             if self.wassilence != 0:
                 self.wassilence = 0
-                return -1 # newly found noise
+                return -1  # newly found noise
-            return 0 # noise again
+            return 0       # noise again
     def repr_res(self, res, frames_read, samplerate):
         fmt_out = None
     def __call__(self, block):
         ret = super(process_cut, self).__call__(block)
-        if ret: self.slices.append(self.onset.get_last())
+        if ret:
+            self.slices.append(self.onset.get_last())
         return ret
     def flush(self, frames_read, samplerate):
-        from aubio.cut import _cut_slice
         _cut_slice(self.options, self.slices)
-        duration = float (frames_read) / float(samplerate)
+        duration = float(frames_read) / float(samplerate)
-        base_info = '%(source_file)s' % {'source_file': self.options.source_uri}
+        base_info = '%(source_file)s' % \
+                    {'source_file': self.options.source_uri}
         base_info += ' (total %(duration).2fs at %(samplerate)dHz)\n' % \
-                {'duration': duration, 'samplerate': samplerate}
+                     {'duration': duration, 'samplerate': samplerate}
         info = "created %d slices from " % len(self.slices)
         info += base_info
         sys.stderr.write(info)
+def _cut_slice(options, timestamps):
+    # cutting pass
+    nstamps = len(timestamps)
+    if nstamps > 0:
+        # generate output files
+        timestamps_end = None
+        if options.cut_every_nslices:
+            timestamps = timestamps[::options.cut_every_nslices]
+            nstamps = len(timestamps)
+        if options.cut_until_nslices and options.cut_until_nsamples:
+            msg = "using cut_until_nslices, but cut_until_nsamples is set"
+            warnings.warn(msg)
+        if options.cut_until_nsamples:
+            lag = options.cut_until_nsamples
+            timestamps_end = [t + lag for t in timestamps[1:]]
+            timestamps_end += [1e120]
+        if options.cut_until_nslices:
+            slice_lag = options.cut_until_nslices
+            timestamps_end = [t for t in timestamps[1 + slice_lag:]]
+            timestamps_end += [1e120] * (options.cut_until_nslices + 1)
+        aubio.slice_source_at_stamps(options.source_uri,
+                timestamps, timestamps_end = timestamps_end,
+                output_dir = options.output_directory,
+                samplerate = options.samplerate,
+                create_first = options.create_first)
 def main():
     parser = aubio_parser()
     if sys.version_info[0] != 3:
         parser_root.add_argument('-V', '--version', help="show version",
                 action="store_true", dest="show_version")
         args, extras = parser_root.parse_known_args()
-        if args.show_version == False: # no -V, forward to parser
+        if not args.show_version:  # no -V, forward to parser
             args = parser.parse_args(extras, namespace=args)
-        elif len(extras) != 0: # -V with other arguments, print help
+        elif len(extras) != 0:     # -V with other arguments, print help
             parser.print_help()
             sys.exit(1)
-    else: # in py3, we can simply use parser directly
+    else:  # in py3, we can simply use parser directly
         args = parser.parse_args()
     if 'show_version' in args and args.show_version:
         sys.stdout.write('aubio version ' + aubio.version + '\n')
         sys.exit(0)
     elif 'verbose' in args and args.verbose > 3:
         sys.stderr.write('aubio version ' + aubio.version + '\n')
-    if 'command' not in args or args.command is None or args.command in ['help']:
+    if 'command' not in args or args.command is None \
+            or args.command in ['help']:
         # no command given, print help and return 1
         parser.print_help()
         if args.command and args.command in ['help']:
                 # increment total number of frames read
                 frames_read += read
                 # exit loop at end of file
-                if read < a_source.hop_size: break
+                if read < a_source.hop_size:
+                    break
             # flush the processor if needed
             processor.flush(frames_read, a_source.samplerate)
             if args.verbose > 1:
                 fmt_string += " ({:d} samples in {:d} blocks of {:d})"
                 fmt_string += " from {:s} at {:d}Hz\n"
                 sys.stderr.write(fmt_string.format(
-                        frames_read/float(a_source.samplerate),
+                        frames_read / float(a_source.samplerate),
                         frames_read,
                         frames_read // a_source.hop_size + 1,
                         a_source.hop_size,

python/lib/aubio/cut.py+29−49

 """
 import sys
-from aubio.cmd import AubioArgumentParser
+from aubio.cmd import AubioArgumentParser, _cut_slice
 def aubio_cut_parser():
     parser = AubioArgumentParser()
     parser.add_input()
-    parser.add_argument("-O","--onset-method",
+    parser.add_argument("-O", "--onset-method",
             action="store", dest="onset_method", default='default',
             metavar = "<onset_method>",
             help="onset detection method [default=default] \
                     complexdomain|hfc|phase|specdiff|energy|kl|mkl")
     # cutting methods
-    parser.add_argument("-b","--beat",
+    parser.add_argument("-b", "--beat",
             action="store_true", dest="beat", default=False,
             help="slice at beat locations")
     """
-    parser.add_argument("-S","--silencecut",
+    parser.add_argument("-S", "--silencecut",
             action="store_true", dest="silencecut", default=False,
             help="use silence locations")
-    parser.add_argument("-s","--silence",
+    parser.add_argument("-s", "--silence",
             metavar = "<value>",
             action="store", dest="silence", default=-70,
             help="silence threshold [default=-70]")
             """
     # algorithm parameters
     parser.add_buf_hop_size()
-    parser.add_argument("-t","--threshold", "--onset-threshold",
+    parser.add_argument("-t", "--threshold", "--onset-threshold",
             metavar = "<threshold>", type=float,
             action="store", dest="threshold", default=0.3,
             help="onset peak picking threshold [default=0.3]")
-    parser.add_argument("-c","--cut",
+    parser.add_argument("-c", "--cut",
             action="store_true", dest="cut", default=False,
             help="cut input sound file at detected labels")
     parser.add_minioi()
     """
-    parser.add_argument("-D","--delay",
+    parser.add_argument("-D", "--delay",
             action = "store", dest = "delay", type = float,
             metavar = "<seconds>", default=0,
             help="number of seconds to take back [default=system]\
                     default system delay is 3*hopsize/samplerate")
-    parser.add_argument("-C","--dcthreshold",
+    parser.add_argument("-C", "--dcthreshold",
             metavar = "<value>",
             action="store", dest="dcthreshold", default=1.,
             help="onset peak picking DC component [default=1.]")
-    parser.add_argument("-L","--localmin",
+    parser.add_argument("-L", "--localmin",
             action="store_true", dest="localmin", default=False,
             help="use local minima after peak detection")
-    parser.add_argument("-d","--derivate",
+    parser.add_argument("-d", "--derivate",
             action="store_true", dest="derivate", default=False,
             help="derivate onset detection function")
-    parser.add_argument("-z","--zerocross",
+    parser.add_argument("-z", "--zerocross",
             metavar = "<value>",
             action="store", dest="zerothres", default=0.008,
             help="zero-crossing threshold for slicing [default=0.00008]")
     # plotting functions
-    parser.add_argument("-p","--plot",
+    parser.add_argument("-p", "--plot",
             action="store_true", dest="plot", default=False,
             help="draw plot")
-    parser.add_argument("-x","--xsize",
+    parser.add_argument("-x", "--xsize",
             metavar = "<size>",
             action="store", dest="xsize", default=1.,
             type=float, help="define xsize for plot")
-    parser.add_argument("-y","--ysize",
+    parser.add_argument("-y", "--ysize",
             metavar = "<size>",
             action="store", dest="ysize", default=1.,
             type=float, help="define ysize for plot")
-    parser.add_argument("-f","--function",
+    parser.add_argument("-f", "--function",
             action="store_true", dest="func", default=False,
             help="print detection function")
-    parser.add_argument("-n","--no-onsets",
+    parser.add_argument("-n", "--no-onsets",
             action="store_true", dest="nplot", default=False,
             help="do not plot detected onsets")
-    parser.add_argument("-O","--outplot",
+    parser.add_argument("-O", "--outplot",
             metavar = "<output_image>",
             action="store", dest="outplot", default=None,
             help="save plot to output.{ps,png}")
-    parser.add_argument("-F","--spectrogram",
+    parser.add_argument("-F", "--spectrogram",
             action="store_true", dest="spectro", default=False,
             help="add spectrogram to the plot")
     """
         options.samplerate = samplerate
     if options.beat:
-        o = tempo(options.onset_method, bufsize, hopsize, samplerate=samplerate)
+        o = tempo(options.onset_method, bufsize, hopsize,
+                samplerate=samplerate)
     else:
-        o = onset(options.onset_method, bufsize, hopsize, samplerate=samplerate)
+        o = onset(options.onset_method, bufsize, hopsize,
+                samplerate=samplerate)
         if options.minioi:
             if options.minioi.endswith('ms'):
                 o.set_minioi_ms(int(options.minioi[:-2]))
     while True:
         samples, read = s()
         if o(samples):
-            timestamps.append (o.get_last())
+            timestamps.append(o.get_last())
-            if options.verbose: print ("%.4f" % o.get_last_s())
+            if options.verbose:
+                print("%.4f" % o.get_last_s())
         total_frames += read
-        if read < hopsize: break
+        if read < hopsize:
+            break
     del s
     return timestamps, total_frames
-def _cut_slice(options, timestamps):
-    # cutting pass
-    nstamps = len(timestamps)
-    if nstamps > 0:
-        # generate output files
-        from aubio.slicing import slice_source_at_stamps
-        timestamps_end = None
-        if options.cut_every_nslices:
-            timestamps = timestamps[::options.cut_every_nslices]
-            nstamps = len(timestamps)
-        if options.cut_until_nslices and options.cut_until_nsamples:
-            print ("warning: using cut_until_nslices, but cut_until_nsamples is set")
-        if options.cut_until_nsamples:
-            timestamps_end = [t + options.cut_until_nsamples for t in timestamps[1:]]
-            timestamps_end += [ 1e120 ]
-        if options.cut_until_nslices:
-            timestamps_end = [t for t in timestamps[1 + options.cut_until_nslices:]]
-            timestamps_end += [ 1e120 ] * (options.cut_until_nslices + 1)
-        slice_source_at_stamps(options.source_uri,
-                timestamps, timestamps_end = timestamps_end,
-                output_dir = options.output_directory,
-                samplerate = options.samplerate,
-                create_first = options.create_first)
 def main():
     parser = aubio_cut_parser()
     options = parser.parse_args()
     timestamps, total_frames = _cut_analyze(options)
     # print some info
-    duration = float (total_frames) / float(options.samplerate)
+    duration = float(total_frames) / float(options.samplerate)
     base_info = '%(source_uri)s' % {'source_uri': options.source_uri}
     base_info += ' (total %(duration).2fs at %(samplerate)dHz)\n' % \
             {'duration': duration, 'samplerate': options.samplerate}

python/lib/aubio/midiconv.py+17−12

 # -*- coding: utf-8 -*-
 """ utilities to convert midi note number to and from note names """
-__all__ = ['note2midi', 'midi2note', 'freq2note', 'note2freq']
 import sys
 from ._aubio import freqtomidi, miditofreq
+__all__ = ['note2midi', 'midi2note', 'freq2note', 'note2freq']
 py3 = sys.version_info[0] == 3
 if py3:
     str_instances = str
     str_instances = (str, unicode)
     int_instances = (int, long)
 def note2midi(note):
     """Convert note name to midi note number.
     --------
     midi2note, freqtomidi, miditofreq
     """
-    _valid_notenames = {'C': 0, 'D': 2, 'E': 4, 'F': 5, 'G': 7, 'A': 9, 'B': 11}
+    _valid_notenames = {'C': 0, 'D': 2, 'E': 4, 'F': 5, 'G': 7,
+                        'A': 9, 'B': 11}
     _valid_modifiers = {
-            u'𝄫': -2,                        # double flat
+            u'𝄫': -2,                         # double flat
-            u'♭': -1, 'b': -1, '\u266d': -1, # simple flat
+            u'♭': -1, 'b': -1, '\u266d': -1,  # simple flat
-            u'♮': 0, '\u266e': 0, None: 0,   # natural
+            u'♮': 0, '\u266e': 0, None: 0,    # natural
-            '#': +1, u'♯': +1, '\u266f': +1, # sharp
+            '#': +1, u'♯': +1, '\u266f': +1,  # sharp
-            u'𝄪': +2,                        # double sharp
+            u'𝄪': +2,                         # double sharp
             }
     _valid_octaves = range(-1, 10)
     if not isinstance(note, str_instances):
     if len(note) not in range(2, 5):
         msg = "string of 2 to 4 characters expected, got {:d} ({:s})"
         raise ValueError(msg.format(len(note), note))
-    notename, modifier, octave = [None]*3
+    notename, modifier, octave = [None] * 3
     if len(note) == 4:
         notename, modifier, octave_sign, octave = note
     if octave not in _valid_octaves:
         raise ValueError("%s is not a valid octave" % octave)
-    midi = 12 + octave * 12 + _valid_notenames[notename] \
+    midi = (octave + 1) * 12 + _valid_notenames[notename] \
-            + _valid_modifiers[modifier]
+                             + _valid_modifiers[modifier]
     if midi > 127:
         raise ValueError("%s is outside of the range C-2 to G8" % note)
     return midi
 def midi2note(midi):
     """Convert midi note number to note name.
         msg = "an integer between 0 and 127 is excepted, got {:d}"
         raise ValueError(msg.format(midi))
     _valid_notenames = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#',
-            'A', 'A#', 'B']
+                        'A', 'A#', 'B']
     return _valid_notenames[midi % 12] + str(int(midi / 12) - 1)
 def freq2note(freq):
     """Convert frequency in Hz to nearest note name.
     nearest_note = int(freqtomidi(freq) + .5)
     return midi2note(nearest_note)
 def note2freq(note):
     """Convert note name to corresponding frequency, in Hz.

python/lib/aubio/slicing.py+10−11

 _max_timestamp = 1e120
 def slice_source_at_stamps(source_file, timestamps, timestamps_end=None,
                            output_dir=None, samplerate=0, hopsize=256,
                            create_first=False):
     the file.
     """
-    if timestamps is None or len(timestamps) == 0:
+    if not timestamps:
         raise ValueError("no timestamps given")
     if timestamps[0] != 0 and create_first:
         timestamps_end = [t - 1 for t in timestamps[1:]] + [_max_timestamp]
     regions = list(zip(timestamps, timestamps_end))
-    #print regions
     source_base_name, _ = os.path.splitext(os.path.basename(source_file))
     if output_dir is not None:
             os.makedirs(output_dir)
         source_base_name = os.path.join(output_dir, source_base_name)
-    def new_sink_name(source_base_name, timestamp, samplerate):
+    def _new_sink_name(source_base_name, timestamp, samplerate):
-        """ create a sink based on a timestamp in samples, converted in seconds """
+        # create name based on a timestamp in samples, converted in seconds
         timestamp_seconds = timestamp / float(samplerate)
         return source_base_name + "_%011.6f" % timestamp_seconds + '.wav'
         # get hopsize new samples from source
         vec, read = _source.do_multi()
         # if the total number of frames read will exceed the next region start
-        while len(regions) and total_frames + read >= regions[0][0]:
+        while regions and total_frames + read >= regions[0][0]:
-            #print "getting", regions[0], "at", total_frames
             # get next region
             start_stamp, end_stamp = regions.pop(0)
             # create a name for the sink
-            new_sink_path = new_sink_name(source_base_name, start_stamp, samplerate)
+            new_sink_path = _new_sink_name(source_base_name, start_stamp,
+                                           samplerate)
             # create its sink
             _sink = sink(new_sink_path, samplerate, _source.channels)
             # create a dictionary containing all this
-            new_slice = {'start_stamp': start_stamp, 'end_stamp': end_stamp, 'sink': _sink}
+            new_slice = {'start_stamp': start_stamp, 'end_stamp': end_stamp,
+                         'sink': _sink}
             # append the dictionary to the current list of slices
             slices.append(new_slice)
             start = max(start_stamp - total_frames, 0)
             # number of samples yet to written be until end of region
             remaining = end_stamp - total_frames + 1
-            #print current_slice, remaining, start
             # not enough frames remaining, time to split
             if remaining < read:
                 if remaining > start:
                     # write remaining samples from current region
                     _sink.do_multi(vec[:, start:remaining], remaining - start)
-                    #print("closing region", "remaining", remaining)
                     # close this file
                     _sink.close()
             elif read > start:
         total_frames += read
         # remove old slices
         slices = list(filter(lambda s: s['end_stamp'] > total_frames,
-            slices))
+                             slices))
         if read < hopsize:
             break

Merge branch 'master' into feature/pytest

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code