If it doesn’t fit anywhere else in the common directory, you’ll find it here…


music21.common.misc.cleanedFlatNotation(music_str: str) str

Returns a copy of the given string where each occurrence of a flat note specified with a ‘b’ is replaced by a ‘-‘.

music_str is a string containing a note specified (for example in a chord)

Returns a new string with flats only specified with ‘-‘.

>>> common.cleanedFlatNotation('Cb')
music21.common.misc.defaultDeepcopy(obj, memo, callInit=True)

Unfortunately, it is not possible to do something like:

def __deepcopy__(self, memo):
    if self._noDeepcopy:
        return self.__class__()
        copy.deepcopy(self, memo, ignore__deepcopy__=True)

Or, else: return NotImplemented

so that’s what this is for:

def __deepcopy__(self, memo):
    if self._noDeepcopy:
        return self.__class__()
        return common.defaultDeepcopy(self, memo)

looks through both __slots__ and __dict__ and does a deepcopy of anything in each of them and returns the new object.

If callInit is False, then only __new__() is called. This is much faster if you’re just going to overload every instance variable.

music21.common.misc.flattenList(originalList: List) List

Flatten a list of lists into a flat list

but not a list of lists of lists…

>>> l = [[1, 2, 3], [4, 5], [6]]
>>> common.flattenList(l)
[1, 2, 3, 4, 5, 6]

Given a list of missing module names, returns a nicely-formatted message to the user that gives instructions on how to expand music21 with optional packages.

>>> print(common.getMissingImportStr(['matplotlib']))
Certain music21 functions might need the optional package matplotlib;
if you run into errors, install it by following the instructions at
>>> print(common.getMissingImportStr(['matplotlib', 'numpy']))
Certain music21 functions might need these optional packages: matplotlib, numpy;
if you run into errors, install them by following the instructions at
music21.common.misc.getPlatform() str

Return the name of the platform, where platforms are divided between ‘win’ (for Windows), ‘darwin’ (for MacOS X), and ‘nix’ for (GNU/Linux and other variants).

Does not discern between Linux/FreeBSD, etc.

Lowercase names are for backwards compatibility – this existed before the platform module.

music21.common.misc.macOSVersion() Tuple[int, int, int]

On a Mac returns the current version as a tuple of (currently 3) ints, such as: (10, 5, 6) for 10.5.6.

On other systems, returns (0, 0, 0)


utility method that replicates the previous behavior of lists of pitches

music21.common.misc.runningUnderIPython() bool

return bool if we are running under iPython Notebook (not iPython)

(no tests, since will be different)

This post:

says not to do this, but really, I can’t think of another way to have different output as default.

Returns True also for Google Colab

music21.common.misc.sortModules(moduleList: Iterable[Any]) List[object]

Sort a list of imported module names such that most recently modified is first. In ties, last access time is used then module name

Will return a different order each time depending on the last mod time

music21.common.misc.unique(originalList: Iterable, *, key: Optional[Callable] = None) List

Return a List of unique items from an iterable, preserving order. (unlike casting to a set and back)

(And why is this not already in Python?)

>>> common.misc.unique([3, 2, 4, 3, 2, 5])
[3, 2, 4, 5]

Works on any iterable, but order might not be preserved for sets, etc.

>>> common.misc.unique(range(5))
[0, 1, 2, 3, 4]

If key is a function then use that to get the value:

>>> s = converter.parse('tinyNotation: c4 E d C f# e a')
>>> common.misc.unique(s.recurse().notes, key=lambda n:
 [<music21.note.Note C>,
  <music21.note.Note E>,
  <music21.note.Note D>,
  <music21.note.Note F#>,
  <music21.note.Note A>]