Remove *arguments where not used

music21/_version.py

@@ -41,7 +41,7 @@
 Changing this number invalidates old pickles -- do it if the old pickles create a problem.
 '''
 
-__version_info__ = (8, 0, 0, 'a10')  # can be 3-tuple or 4+-tuple: (7, 0, 5, 'a2')
+__version_info__ = (8, 0, 0, 'a11')  # can be 3-tuple or 4+-tuple: (7, 0, 5, 'a2')
 
 v = '.'.join(str(x) for x in __version_info__[0:3])
 if len(__version_info__) > 3 and __version_info__[3]:  # type: ignore

music21/analysis/discrete.py

@@ -22,6 +22,8 @@
 (for algorithmic key detection) and
 :class:`music21.analysis.discrete.Ambitus` (for pitch range analysis) provide examples.
 '''
+from __future__ import annotations
+
 # TODO: make an analysis.base for the Discrete and analyzeStream aspects, then create
 #     range and key modules in analysis
 
@@ -1287,7 +1289,6 @@ def getSolution(self, sStream):
 def analyzeStream(
     streamObj: 'music21.stream.Stream',
     method: str,
-    *args,
     **keywords
 ):
     '''
@@ -1327,10 +1328,10 @@ def analyzeStream(
         # this synonym is being added for compatibility
         method = 'span'
 
-    match: t.Optional[t.Callable] = analysisClassFromMethodName(method)
+    analysisClassName: t.Optional[t.Type[DiscreteAnalysis]] = analysisClassFromMethodName(method)
 
-    if match is not None:
-        obj = match()  # NOTE: Cuthbert, this was previously analysisClassName()? - out of scope
+    if analysisClassName is not None:
+        obj = analysisClassName()
         # environLocal.printDebug(['analysis method used:', obj])
         return obj.getSolution(streamObj)
 
@@ -1339,7 +1340,7 @@ def analyzeStream(
 
 
 # noinspection SpellCheckingInspection
-def analysisClassFromMethodName(method: str):
+def analysisClassFromMethodName(method: str) -> t.Optional[t.Type[DiscreteAnalysis]]:
     '''
     Returns an analysis class given a method name, or None if none can be found
 
@@ -1360,15 +1361,15 @@ def analysisClassFromMethodName(method: str):
     >>> print(repr(acfmn('unknown-format')))
     None
     '''
-    analysisClasses = [
+    analysisClasses: t.List[t.Type[DiscreteAnalysis]] = [
         Ambitus,
         KrumhanslSchmuckler,
         AardenEssen,
         SimpleWeights,
         BellmanBudge,
         TemperleyKostkaPayne,
     ]
-    match = None
+    match: t.Optional[t.Type[DiscreteAnalysis]] = None
     for analysisClass in analysisClasses:
         # this is a very loose matching, as there are few classes now
         if (method.lower() in analysisClass.__name__.lower()

music21/analysis/patel.py

@@ -59,35 +59,31 @@ def nPVI(streamForAnalysis):
     final = summation * 100 / (totalElements - 1)
     return final
 
-def melodicIntervalVariability(streamForAnalysis, *skipArgs, **skipKeywords):
+def melodicIntervalVariability(streamForAnalysis, **skipKeywords):
     '''
-    gives the Melodic Interval Variability (MIV) for a Stream,
+    Gives the Melodic Interval Variability (MIV) for a Stream,
     as defined by Aniruddh D. Patel in "Music, Language, and the Brain"
     p. 223, as 100 x the coefficient of variation (standard deviation/mean)
     of the interval size (measured in semitones) between consecutive elements.
 
+    The multiplication by 100x exists to put it in the same range as nPVI.
 
-    the 100x is designed to put it in the same range as nPVI
+    Keywords are passed on to
+    Stream.findConsecutiveNotes() via Stream.melodicIntervals for
+    determining how to find consecutive intervals.
 
-
-    this method takes the same arguments of skipArgs and skipKeywords as
-    Stream.melodicIntervals() for determining how to find consecutive
-    intervals.
-
-
-
-    >>> s2 = converter.parse('tinynotation: 4/4 C4 D E F# G#').flatten().notesAndRests.stream()
+    >>> s2 = converter.parse('tinynotation: 4/4 C4 D E F# G#')[note.Note].stream()
     >>> analysis.patel.melodicIntervalVariability(s2)
     0.0
-    >>> s3 = converter.parse('tinynotation: 4/4 C4 D E F G C').flatten().notesAndRests.stream()
+    >>> s3 = converter.parse('tinynotation: 4/4 C4 D E F G C')[note.Note].stream()
     >>> analysis.patel.melodicIntervalVariability(s3)
     85.266688...
-    >>> s4 = corpus.parse('bwv66.6').parts[0].flatten().notesAndRests.stream()
+    >>> s4 = corpus.parse('bwv66.6').parts[0][note.GeneralNote].stream()
     >>> analysis.patel.melodicIntervalVariability(s4)
     65.287...
     '''
     s = streamForAnalysis  # shorter
-    intervalStream = s.melodicIntervals(skipArgs, skipKeywords)
+    intervalStream = s.melodicIntervals(**skipKeywords)
     totalElements = len(intervalStream)
     if totalElements < 2:
         raise PatelException('need at least three notes to have '

music21/analysis/reduction.py

@@ -113,7 +113,7 @@ def _reprInternal(self):
     def __getitem__(self, key):
         return self._parameters[key]
 
-    def _parseSpecification(self, spec):
+    def _parseSpecification(self, spec: str):
         # start with the defaults
         self._parameters = copy.deepcopy(self._defaultParameters)
         spec = spec.strip()
@@ -133,7 +133,7 @@ def _parseSpecification(self, spec):
                 self._parameters[attr] = value
         self._isParsed = True
 
-    def isParsed(self):
+    def isParsed(self) -> bool:
         return self._isParsed
 
     def getNoteAndTextExpression(self):
@@ -199,7 +199,7 @@ class ScoreReduction:
     '''
     An object to reduce a score.
     '''
-    def __init__(self, *args, **keywords):
+    def __init__(self, **keywords):
         # store a list of one or more reductions
         self._reductiveNotes = {}
         self._reductiveVoices = []
@@ -464,7 +464,7 @@ class PartReduction:
     '''
     def __init__(self,
                  srcScore=None,
-                 *args,
+                 *,
                  partGroups: t.Optional[t.List[t.Dict[str, t.Any]]] = None,
                  fillByMeasure: bool = True,
                  segmentByTarget: bool = True,

music21/base.py

@@ -28,7 +28,7 @@
 <class 'music21.base.Music21Object'>
 
 >>> music21.VERSION_STR
-'8.0.0a10'
+'8.0.0a11'
 
 Alternatively, after doing a complete import, these classes are available
 under the module "base":
@@ -341,7 +341,6 @@ class Music21Object(prebase.ProtoM21Object):
     }
 
     def __init__(self,
-                 *arguments,
                  id: t.Union[str, int, None] = None,  # pylint: disable=redefined-builtin
                  groups: t.Optional[Groups] = None,
                  sites: t.Optional[Sites] = None,
@@ -1161,11 +1160,11 @@ def getSpannerSites(self,
             if obj is None:  # pragma: no cover
                 continue
             if spannerClassList is None:
-                post.append(obj.spannerParent)
+                post.append(obj.client)
             else:
                 for spannerClass in spannerClassList:
-                    if spannerClass in obj.spannerParent.classSet:
-                        post.append(obj.spannerParent)
+                    if spannerClass in obj.client.classSet:
+                        post.append(obj.client)
                         break
 
         return post
@@ -1800,7 +1799,6 @@ def contextSites(
                      offset=0.0,
                      recurseType='elementsFirst')
 
-
         >>> partIterator = c.parts
         >>> m3 = partIterator[1].measure(3)
         >>> for csTuple in m3.contextSites():
@@ -2366,7 +2364,7 @@ def offset(self) -> OffsetQL:
         thus the place where `.offset` looks to find its number.
 
         >>> m2 = stream.Measure()
-        >>> m2.insert(3.0/5, n1)
+        >>> m2.insert(3/5, n1)
         >>> m2.number = 5
         >>> n1.offset
         Fraction(3, 5)
@@ -2387,20 +2385,17 @@ def offset(self) -> OffsetQL:
         >>> n1.offset
         10.0
 
-
         The property can also set the offset for the object if no
         container has been set:
 
-
         >>> n1 = note.Note()
         >>> n1.id = 'hi'
-        >>> n1.offset = 20/3.
+        >>> n1.offset = 20/3
         >>> n1.offset
         Fraction(20, 3)
         >>> float(n1.offset)
         6.666...
 
-
         >>> s1 = stream.Stream()
         >>> s1.append(n1)
         >>> n1.offset

music21/braille/segment.py

@@ -167,9 +167,9 @@ class BrailleElementGrouping(ProtoM21Object):
         'withHyphen': 'If True, this grouping will end with a music hyphen.',
         'numRepeats': 'The number of times this grouping is repeated.'
     }
-    def __init__(self, *args):
+    def __init__(self, *listElements):
         '''
-        A BrailleElementGrouping is a superclass of list of objects which should be displayed
+        A BrailleElementGrouping mimics a list of objects which should be displayed
         without a space in braille.
 
         >>> from music21.braille import segment
@@ -209,8 +209,7 @@ def __init__(self, *args):
         >>> bg.numRepeats
         0
         '''
-        super().__init__()
-        self.internalList = list(*args)
+        self.internalList = list(*listElements)
         setGroupingGlobals()
 
         self.keySignature = GROUPING_GLOBALS['keySignature']

music21/braille/test.py

@@ -2706,7 +2706,10 @@ def test_example13_2(self):
 
     def xtest_example13_3(self):
         # Problem: How to plug in wedges into music21?
-        bm = converter.parse('tinynotation: a1 a1 a1 a1', 'c').flatten()
+        bm = converter.parse('tinynotation: 4/4 a1 a1 a1 a1').flatten()
+        commonTime = bm[meter.TimeSignature].first()
+        if commonTime is not None:  # it is not None, but for typing
+            commonTime.symbol = 'common'
         bm.makeNotation(inPlace=True, cautionaryNotImmediateRepeat=False)
         ml = bm.getElementsByClass(stream.Measure)
         ml[-1].rightBarline = None

music21/chord/__init__.py

@@ -3597,6 +3597,8 @@ def isTriad(self) -> bool:
         False
 
         >>> incorrectlySpelled.pitches[1].getEnharmonic(inPlace=True)
+        >>> incorrectlySpelled
+        <music21.chord.Chord C E- G>
         >>> incorrectlySpelled.isTriad()
         True
 

music21/common/decorators.py

@@ -26,27 +26,27 @@ def optional_arg_decorator(fn):
     a decorator for decorators.  Allows them to either have or not have arguments.
     '''
     @wraps(fn)
-    def wrapped_decorator(*args, **keywords):
-        is_bound_method = hasattr(args[0], fn.__name__) if args else False
+    def wrapped_decorator(*arguments, **keywords):
+        is_bound_method = hasattr(arguments[0], fn.__name__) if arguments else False
         klass = None
 
         if is_bound_method:
-            klass = args[0]
-            args = args[1:]
+            klass = arguments[0]
+            arguments = arguments[1:]
 
         # If no arguments were passed...
-        if len(args) == 1 and not keywords and callable(args[0]):
+        if len(arguments) == 1 and not keywords and callable(arguments[0]):
             if is_bound_method:
-                return fn(klass, args[0])
+                return fn(klass, arguments[0])
             else:
-                return fn(args[0])
+                return fn(arguments[0])
 
         else:
             def real_decorator(toBeDecorated):
                 if is_bound_method:
-                    return fn(klass, toBeDecorated, *args, **keywords)
+                    return fn(klass, toBeDecorated, *arguments, **keywords)
                 else:
-                    return fn(toBeDecorated, *args, **keywords)
+                    return fn(toBeDecorated, *arguments, **keywords)
             return real_decorator
     return wrapped_decorator
 
@@ -129,11 +129,12 @@ def deprecated(method, startDate=None, removeDate=None, message=None):
                 'message': m}
 
     @wraps(method)
-    def func_wrapper(*args, **keywords):
-        if len(args) > 1 and args[1] in ('_ipython_canary_method_should_not_exist_',
-                                         '_repr_mimebundle_',
-                                         '_is_coroutine',
-                                         ):
+    def func_wrapper(*arguments, **keywords):
+        if len(arguments) > 1 and arguments[1] in (
+            '_ipython_canary_method_should_not_exist_',
+            '_repr_mimebundle_',
+            '_is_coroutine'
+        ):
             # false positive from IPython for StreamIterator.__getattr__
             # can remove after v9.
             falsePositive = True
@@ -147,7 +148,7 @@ def func_wrapper(*args, **keywords):
                           exceptions21.Music21DeprecationWarning,
                           stacklevel=2)
             callInfo['calledAlready'] = True
-        return method(*args, **keywords)
+        return method(*arguments, **keywords)
 
     return func_wrapper
 
@@ -175,11 +176,11 @@ def cacheMethod(method):
         funcName = method.__name__
 
     @wraps(method)
-    def inner(instance, *args, **keywords):
+    def inner(instance, *arguments, **keywords):
         if funcName in instance._cache:
             return instance._cache[funcName]
 
-        instance._cache[funcName] = method(instance, *args, **keywords)
+        instance._cache[funcName] = method(instance, *arguments, **keywords)
         return instance._cache[funcName]
 
     return inner

music21/common/stringTools.py

@@ -262,10 +262,11 @@ def getMd5(value=None) -> str:
 
 
 def formatStr(msg,
-              *args,
-              format: t.Optional[str] = None,  # pylint: disable=redefined-builtin
+              *rest_of_message,
               **keywords) -> str:
     '''
+    DEPRECATED: do not use.  May be removed at any time.
+
     Format one or more data elements into string suitable for printing
     straight to stderr or other outputs
 
@@ -274,8 +275,7 @@ def formatStr(msg,
     test 1 2 3
     <BLANKLINE>
     '''
-
-    msg = [msg] + list(args)
+    msg = [msg, *rest_of_message]
     for i in range(len(msg)):
         x = msg[i]
         if isinstance(x, bytes):
@@ -288,10 +288,7 @@ def formatStr(msg,
                     msg[i] = x.decode('utf-8')
                 except AttributeError:
                     msg[i] = ''
-    if format == 'block':
-        return '\n*** '.join(msg) + '\n'
-    else:  # catch all others
-        return ' '.join(msg) + '\n'
+    return ' '.join(msg) + '\n'
 
 
 def stripAccents(inputString: str) -> str:

music21/converter/__init__.py

@@ -1192,7 +1192,7 @@ def parseURL(url,
 
 
 def parse(value: t.Union[bundles.MetadataEntry, bytes, str, pathlib.Path],
-          *args,
+          *,
           forceSource: bool = False,
           number: t.Optional[int] = None,
           format: t.Optional[str] = None,  # pylint: disable=redefined-builtin

music21/derivation.py

@@ -52,8 +52,8 @@ def derivationMethod(function):
     <Derivation of <music21.note.Note D-> from <music21.note.Note C#> via 'allGreen'>
     '''
     @functools.wraps(function)
-    def wrapper(self, *args, **keywords):
-        result = function(self, *args, **keywords)
+    def wrapper(self, *arguments, **keywords):
+        result = function(self, *arguments, **keywords)
         result.derivation.origin = self
         result.derivation.method = function.__name__
         return result