j`'dZddlmZddlZddlZGddZ[GddejZe dkrddl Z e j edSdS) z Classes for pseudo-m21 objects to inherit from. The most import attributes that nearly everything in music21 -- not just things that live in streams -- should inherit from are given below. Concept borrowed from m21j. ) annotationsNceZdZUdZddgZiZded<iZded<iZded <d Z d ed <e ddZ e ddZ ddZ ddZdS)ProtoM21Objectam A class for pseudo-m21 objects to inherit from. Any object can inherit from ProtoM21Object, and it makes sense for anything a user is likely to encounter to inherit from it. Certain translators, etc. can choose to skip it. >>> class PitchCounter(prebase.ProtoM21Object): ... def _reprInternal(self): ... return 'no pitches' >>> pc = PitchCounter() >>> pc.classes ('PitchCounter', 'ProtoM21Object', 'object') >>> PitchCounter in pc.classSet True >>> 'Note' in pc.classSet False For a True/False intersection check against an iterable, use `classSet.isdisjoint`: >>> classList = ('music21.note.Note', 'music21.note.Rest') >>> pc.classSet.isdisjoint(classList) True >>> repr(pc) '<...PitchCounter no pitches>' ProtoM21Objects, like other Python primitives, cannot be put into streams -- this is what base.Music21Object does. A ProtoM21Object defines several methods relating to unified representation and keeping track of the classes of the object. It has no instance attributes or properties, and thus adds a very small creation time impact: recent tests show that an empty object with an empty `__init__()` method can be created in about 175ns while an empty object that subclasses ProtoM21Object with the same empty `__init__()` takes only 180ns, or a 5ns impact. On real objects, the creation time percentage hit is usually much smaller. ProtoM21Objects have no __init__() defined, so do not call super().__init__() on objects that only inherit from ProtoM21Object unless you like wasting 200ns. classesclassSetzdict[str, str] _DOC_ATTRzdict[type, tuple[str, ...]]_classTupleCacheDictz!dict[type, frozenset[str | type]]_classSetCacheDicttuple[str, ...] __slots__returnc |j|jS#t$rDtd|jD}||j|j<|cYSwxYw)a[ Returns a tuple containing the names (strings, not objects) of classes that this object belongs to -- starting with the object's class name and going up the mro() for the object. Notes are Music21Objects: >>> n = note.Note('C#') >>> n.classes ('Note', 'NotRest', 'GeneralNote', 'Music21Object', 'ProtoM21Object', 'object') Durations are not, but they inherit from ProtoM21Object >>> d = duration.Duration('half') >>> d.classes ('Duration', 'ProtoM21Object', 'SlottedObjectMixin', 'object') Having quick access to these things as strings makes it easier to do comparisons: Example: find GClefs that are not Treble clefs (or treble 8vb, etc.): >>> s = stream.Stream() >>> s.insert(10, clef.GClef()) >>> s.insert(20, clef.TrebleClef()) >>> s.insert(30, clef.FrenchViolinClef()) >>> s.insert(40, clef.Treble8vbClef()) >>> s.insert(50, clef.BassClef()) >>> s2 = stream.Stream() >>> for thing in s: ... if isinstance(thing, clef.GClef) and not isinstance(thing, clef.TrebleClef): ... s2.insert(thing) >>> s2.show('text') {10.0} {30.0} * Changed in v2: returns a tuple, not a list. c3$K|] }|jV dS)N)__name__.0xs /Users/tedpeters/Documents/Projects/Claude Projects/Misc Tools/notename-sheets/.venv/lib/python3.11/site-packages/music21/prebase.py z)ProtoM21Object.classes..zs$HHaqzHHHHHH)r __class__KeyErrortuplemro)self classTuples rrzProtoM21Object.classesPsxN ,T^< <   HH4>3E3E3G3GHHHHHJ8BD %dn 5    sA A"!A"frozenset[str | type]c |j|jS#t$rt|j}||jd|jD}||d|D}||t|}||j|j<|cYSwxYw)a Returns a set (that is, unordered, but indexed) of all classes that this class belongs to, including string names, fullyQualified string names, and objects themselves. It's cached on a per-class basis, so makes for a really fast way of checking to see if something belongs to a particular class when you don't know if the user has given a string, a fully qualified string name, or an object. Did I mention it's fast? It's not as fast as x in n.classes or isinstance(n, x) if you know whether it's a string or class, but this is good and safe to take in either a string or a class. >>> n = note.Note() >>> 'Note' in n.classSet True >>> 'music21.note.Note' in n.classSet True >>> note.Note in n.classSet True >>> 'Rest' in n.classSet False >>> note.Rest in n.classSet False For checking if an object is part of any number of objects use `not` with `isdisjoint`. A little unwiedly but works super fast: >>> checkClasses = (spanner.Slur, note.NotRest) >>> not n.classSet.isdisjoint(checkClasses) True >>> object in n.classSet True >>> sorted([s for s in n.classSet if isinstance(s, str)]) ['GeneralNote', 'Music21Object', 'NotRest', 'Note', 'ProtoM21Object', 'base.Music21Object', 'builtins.object', 'music21.base.Music21Object', 'music21.note.GeneralNote', 'music21.note.NotRest', 'music21.note.Note', 'music21.prebase.ProtoM21Object', 'note.GeneralNote', 'note.NotRest', 'note.Note', 'object', 'prebase.ProtoM21Object'] >>> sorted([s for s in n.classSet if not isinstance(s, str)], key=lambda x: x.__name__) [, , , , , ] * Changed in v8: partially qualified objects such as 'note.Note' have been added. c2g|]}|jdz|jzS).) __module__rrs r z+ProtoM21Object.classSet..s&$c$c$cQ\C%7!*%D$c$c$crc:g|]}|ddS)zmusic21.)replacers rr#z+ProtoM21Object.classSet..s&(b(b(bq:r)B)B(b(b(br)r rrlistrextendr frozenset)r classListfullyQualifiedStringspartiallyQualifiedStringsrs rrzProtoM21Object.classSet~sH *4>: :   (,T\(:(:I   T^//11 2 2 2$c$cdnN`N`NbNb$c$c$c !   2 3 3 3(b(bLa(b(b(b %   6 7 7 7 ++H6>D #DN 3OOO sCCCstrc,d}|jdkr ||jdzz }||jjz }d|vrd|vr|dd}|}|r|ds|d z }|r||z }|d zS) a^ Defines the default representation for a ProtoM21Object which includes the module name, the class name, and additional information, such as the memory location: >>> p = prebase.ProtoM21Object() >>> repr(p) '' The additional information is defined in the `_reprInternal` method, so objects inheriting from ProtoM21Object (such as Music21Object) should change `_reprInternal` and not `__repr__`. Except for music21.base itself, any object in a file called base.py has the base part removed. >>> from music21.midi.base import MidiEvent >>> me = MidiEvent() >>> repr(me) '' >>> me._reprInternal() 'UNKNOWN, track=None' <__main__r!z.base.z music21.basez.baser%: >)r"r __qualname__r& _reprInternal startswithstrip)rreprHeadstrReprs r__repr__zProtoM21Object.__repr__s0 ?j ( ( #- -HDN// x  N($B$B''44H$$&&  7--c22  OH  (   'H#~rc@dtt|S)av Defines the insides of the representation. Overload this method for most objects. A default representation: >>> p = prebase.ProtoM21Object() >>> p._reprInternal() 'object at 0x112590380' A more complex `_reprInternal` that handles the case of objects with `.id` defined is found in Music21Object. z object at )hexid)rs rr5zProtoM21Object._reprInternals,C4MM+++rN)rr )rr)rr-)rr"r4__doc__ _DOC_ORDERr__annotations__r r r propertyrrr:r5r rrrrs&&T J !#I"""" 9;:::::<<<<) music21.baserJr=repr assertEqual)rrJbrs rtest_reprInternalzTest.test_reprInternalsN...... MOO GG CDDDDDrN)rr"r4rHrQr rrrCrC s7%%%EEEEErrCr0) r> __future__rtypingtunittestrTestCaserCrmusic21mainTestr rrrYs#"""""n,n,n,n,n,n,n,n,b E E E E E8  E E E zNNNGTr