rhf%SrSSKJr /SQrSSKJr SSKrSSKJr SSKr SSK J r SSK J r SS K Jr SS K Jr SS K Jr SS K Jr \R$"S 5r"SS\R(5r\ R,"SSS5S4Sj5r\ R,"SSS5S5Sj5r\S6Sj5r\S7Sj5r\S8Sj5rS9SjrS:Sjr\ R,"SSS5S;Sj5rSSjr"S S!\ 5r"S"S#\ 5r "S$S%\ 5r!"S&S'\ 5r"S(r#\\ -\!-\"-\ RHS)-r%"S*S+\RL5r'"S,S)\'5r("S-S.\RL5r)"S/S0\RL5r*\'\(\)\*/r+S1\,S2'\-S3:XaSSK r \ R\"5 gg)?a Objects and tools for processing MIDI data. Converts from MIDI files to :class:`~music21.midi.MidiEvent`, :class:`~music21.midi.MidiTrack`, and :class:`~music21.midi.MidiFile` objects, and vice-versa. This module originally used routines from Will Ware's public domain midi.py library from 2001 which was once posted at (http link) groups.google.com/g/alt.sources/msg/0c5fc523e050c35e ) annotations) MidiEventMidiFile MidiTrack MidiException DeltaTime MetaEventsChannelVoiceMessagesChannelModeMessages SysExEvents charToBinary getNumbergetVariableLengthNumber putNumberputVariableLengthNumbergetNumbersAsListputNumbersAsListintsToHexBytesr r r METAEVENT_MARKER)IterableN)overload)common) ContainsEnum)defaults) environment) exceptions21)prebasez midi.basec\rSrSrSrg)r8N)__name__ __module__ __qualname____firstlineno____static_attributes__r K/home/james-whalen/.local/lib/python3.13/site-packages/music21/midi/base.pyrr8sr&rzv9.7v10zuse bin(ord(char)) instead.cZ[[U55SSnS[U5- S-nX!-$)a DEPRECATED: just use bin(ord(char)) instead. Or for the exact prior output (with left-padding) use `f'{int(bin(ord(char))[2:]):08d}'` Convert a char into its binary representation. Useful for debugging. >>> #_DOCS_SHOW midi.charToBinary('a') >>> f'{int(bin(ord("a"))[2:]):08d}' #_DOCS_HIDE '01100001' Note: This function is deprecated and will be removed in v10. Music21 actually predates the bin() function in Python (added in Python 2.6). N0)binordlen)charbinaryzeroFixs r'r r <s3$T^AB F3v;#%G  r&zJust use bytes(...) insteadc[U5$)a (Deprecated: just use bytes(...) instead) Convert a list of integers into hex bytes, suitable for testing MIDI encoding. Here we take NOTE_ON message, Middle C, 120 velocity and translate it to bytes >>> #_DOCS_SHOW midi.intsToHexBytes([0x90, 60, 120]) >>> bytes([0x90, 60, 120]) #_DOCS_HIDE b'\x90r&cgNr midiStrlengths r'rrer&cgr7r r8s r'rrir;r&cgr7r r8s r'rrmr;r&cRSn[U[5(dx[U5HcnXn[U[5(a US-U-nM&[R(a[U[ 5(deUS-[ U5-nMe X US4$UnXUSU-- SU--- nXR- nX&4$)a= Return the value of a string byte or bytes if length > 1 from an 8-bit string or bytes object Then, return the remaining string or bytes object The `length` is the number of chars to read. This will sum a length greater than 1 if desired. Note that MIDI uses big-endian for everything. This is the inverse of Python's chr() function. Read first two bytes >>> midi.getNumber(b'test', 2) (29797, b'st') That number comes from: >>> ord('t') * 256 + ord('e') 29797 Demonstration of reading the whole length in: >>> midi.getNumber(b'test', 4) (1952805748, b'') Reading in zero bytes leaves the midiStr unchanged: >>> midi.getNumber(b'test', 0) (0, b'test') The method can also take in an integer and return an integer and the remainder part. This usage might be deprecated in the future and has already been replaced within music21 internal code. >>> midi.getNumber(516, 1) # = 2*256 + 4 (4, 512) As of v9.7, this method can also take a string as input and return a string. This usage is deprecated and will be removed in v10. >>> midi.getNumber('test', 2) (29797, 'st') rr+N) isinstanceintranget TYPE_CHECKINGstrr.)r9r: summationi midiStrOrNummidNumbigBytess r'rrqs^I gs # #vA":L,,,&!^|; ??%lC8888&!^s>> midi.getVariableLengthNumber(b'A-u') (65, b'-u') >>> midi.getVariableLengthNumber(b'-u') (45, b'u') >>> midi.getVariableLengthNumber(b'u') (117, b'') >>> midi.getVariableLengthNumber(b'test') (116, b'est') >>> midi.getVariableLengthNumber(b'E@-E') (69, b'@-E') >>> midi.getVariableLengthNumber(b'@-E') (64, b'-E') >>> midi.getVariableLengthNumber(b'-E') (45, b'E') >>> midi.getVariableLengthNumber(b'E') (69, b'') Test that variable length characters work: >>> midi.getVariableLengthNumber(b'\xff\x7f') (16383, b'') >>> midi.getVariableLengthNumber('中xy'.encode('utf-8')) (210638584, b'y') If no low-byte character is encoded, raises an IndexError >>> midi.getVariableLengthNumber('中国'.encode('utf-8')) Traceback (most recent call last): IndexError: index out of range Up to v9.7, this method could also take a string as input and return a string. This usage is now removed. riNz#did not find the end of the number!)r) midiBytesrErFxs r'rrsgbI A c' L!^D1  QDm+ + c' = >>r&zuse list(midiBytes) insteadc/nUHEn[U[5(aUR[U55 M4URU5 MG U$)a **Deprecated**: this method existed in Python 2.6 and for Python 2 (no bytes) compatibility. Now use `list(midiBytes)` instead. Translate each char into a number, return in a list. Used for reading data messages where each byte encodes a different discrete value. >>> #_DOCS_SHOW midi.getNumbersAsList(b'\x00\x00\x00\x03') >>> list(b'\x00\x00\x00\x03') #_DOCS_HIDE [0, 0, 0, 3] Now just do: >>> list(b'\x00\x00\x00\x03') [0, 0, 0, 3] )r?rDappendr.)rOpostmidiBytes r'rrsC& D h $ $ KKH & KK !  Kr&c[5n[U5H&nSUS- U- -nX- S-nURU5 M( [U5$)a Put a single number as a hex number at the end of a bytes object `length` bytes long. >>> midi.putNumber(3, 4) b'\x00\x00\x00\x03' >>> midi.putNumber(0, 1) b'\x00' >>> midi.putNumber(258, 2) b'\x01\x02' If the number is larger than the length currently only the least significant bytes are returned. This behavior may change in the near future to raise an exception instead. >>> midi.putNumber(258, 1) b'\x02' r+rM) bytearrayrArRr4)numr:lstrFnthisNums r'rr sO& +C 6] !a 8t# 7 :r&cUS:a[SU35e[5nUS-US- pURUS-5 US:XaOM&UR5 USS-US'[ U5$)a Turn an integer number into the smallest bytes object that can hold it for MIDI Numbers < 128 are encoded as single bytes and are the same as bytes([x]) >>> midi.putVariableLengthNumber(4) b'\x04' >>> midi.putVariableLengthNumber(127) b'\x7f' >>> bytes([127]) b'\x7f' >>> midi.putVariableLengthNumber(0) b'\x00' Numbers > 7bit but < 16384 need two characters, with the first character set as 0x80 + n // 128 and the second character set as n % 128: >>> midi.putVariableLengthNumber(128) b'\x81\x00' >>> midi.putVariableLengthNumber(129) b'\x81\x01' >>> midi.putVariableLengthNumber(255) b'\x81\x7f' This differs from the 8-bit representation of `bytes([x])`: >>> bytes([128]) b'\x80' >>> bytes([255]) b'\xff' This method can also deal with numbers > 255, which `bytes` cannot. >>> midi.putVariableLengthNumber(256) b'\x82\x00' >>> bytes([256]) Traceback (most recent call last): ValueError: bytes must be in range(0, 256) It also differs from the normal way of representing 256 in Python bytes: >>> bytes([1, 0]) b'\x01\x00' Here are MIDI representation of other numbers that are too large to fit in 8 bits but stored in two bytes in MIDI. >>> midi.putVariableLengthNumber(1024) b'\x88\x00' Notice that the least significant byte is second. >>> midi.putVariableLengthNumber(8192) b'\xc0\x00' >>> midi.putVariableLengthNumber(8193) b'\xc0\x01' This is the maximum normal MIDI number that can be stored in 2 bytes. >>> midi.putVariableLengthNumber(16383) b'\xff\x7f' Numbers >= 16384 are not used in 2-byte classic MIDI, but this routine continues the basic principle from above: >>> midi.putVariableLengthNumber(16384) b'\x81\x80\x00' >>> midi.putVariableLengthNumber(16384 + 128) b'\x81\x81\x00' >>> midi.putVariableLengthNumber(16384 * 2) b'\x82\x80\x00' >>> midi.putVariableLengthNumber(16384 ** 2) b'\x81\x80\x80\x80\x00' Negative numbers raise MidiException >>> midi.putVariableLengthNumber(-1) Traceback (most recent call last): music21.midi.base.MidiException: cannot putVariableLengthNumber() when number is negative: -1 rz:cannot putVariableLengthNumber() when number is negative: rLrKrN)rrWrRreverser4)rPrYys r'rr*sl 1uXYZX[\]] +C 4xa1 1t8 6   KKM"gnCG :r&c[5nUH3nUS:aUS-nUS:a[SU35eURU5 M5 [U5$)a Translate a list of numbers (0-255) into bytes. Used for encoding data messages where each byte encodes a different discrete value. >>> midi.putNumbersAsList([0, 0, 0, 3]) b'\x00\x00\x00\x03' For positive numbers this method behaves the same as `bytes(numList)` and that method should be used if you are sure all numbers are positive. >>> bytes([0, 0, 0, 3]) b'\x00\x00\x00\x03' If a number is < 0 then it wraps around from the top. This is used in places like MIDI key signatures where flats are represented by `256 - flats`. >>> midi.putNumbersAsList([0, 0, 0, -3]) b'\x00\x00\x00\xfd' >>> midi.putNumbersAsList([0, 0, 0, -1]) b'\x00\x00\x00\xff' The behavior with negative numbers is different from `bytes(numList)` List can be of any length >>> midi.putNumbersAsList([1, 16, 255]) b'\x01\x10\xff' Any number > 255 (or less than -255) raises an exception: >>> midi.putNumbersAsList([256]) Traceback (most recent call last): music21.midi.base.MidiException: Cannot place a number > 255 in a list: 256 rz'Cannot place a number > 255 in a list: )rWrrRr4)numListrSrZs r'rrsWH ;D  q5CA 8"I! MN N A  ;r&c4\rSrSrSrSrSrSrSrSr Sr S r S r g ) r izc ChannelVoiceMessages are the main MIDI messages for channel 1-16, such as NOTE_ON, NOTE_OFF, etc. rNr N) r!r"r#r$__doc__NOTE_OFFNOTE_ONPOLYPHONIC_KEY_PRESSURECONTROLLER_CHANGEPROGRAM_CHANGECHANNEL_KEY_PRESSURE PITCH_BENDr%r r&r'r r s/HG"NJr&r c4\rSrSrSrSrSrSrSrSr Sr S r S r g ) r ixyz{|}~rLr N) r!r"r#r$ ALL_SOUND_OFFRESET_ALL_CONTROLLERS LOCAL_CONTROL ALL_NOTES_OFF OMNI_MODE_OFF OMNI_MODE_ON MONO_MODE_ON POLY_MODE_ONr%r r&r'r r s+M MMMLLLr&r c`\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rSrSrSrSrSrSrSrSrg)r irrMr*rKr+ !/QTXYrLrVr N)r!r"r#r$SEQUENCE_NUMBER TEXT_EVENTCOPYRIGHT_NOTICESEQUENCE_TRACK_NAMEINSTRUMENT_NAMELYRICMARKER CUE_POINT PROGRAM_NAMESOUND_SET_UNSUPPORTEDMIDI_CHANNEL_PREFIX MIDI_PORT END_OF_TRACK SET_TEMPO SMPTE_OFFSETTIME_SIGNATURE KEY_SIGNATURESEQUENCER_SPECIFIC_META_EVENTUNKNOWNr%r r&r'r r shOJO E FIL !ILILNM$(!Gr&r c\rSrSrSrSrSrg)r ir N)r!r"r#r$F0_SYSEX_EVENTF7_SYSEX_EVENTr%r r&r'r r s NNr&r rVrcv\rSrSrSrS\R SS4SSjjr\SSj5r SSjr \SS j5r \ RSS j5r \SS j5r \ RSS j5r \SS j5r\RSSj5rSS SjjrS!SjrS!SjrS"SjrS#SjrS#SjrS#SjrS$SjrSrg)%riaj A model of a MIDI event, including note-on, note-off, program change, controller change, any many others. MidiEvent objects are paired (preceded) by :class:`~music21.midi.DeltaTime` objects in the list of events in a MidiTrack object. The `track` argument must be a :class:`~music21.midi.MidiTrack` object. The `type` attribute is an enumeration of a Midi event from the ChannelVoiceMessages, ChannelModeMessages, SysExEvents, or MetaEvents enums; if unspecified, defaults to MetaEvents.UNKNOWN. The `channel` attribute is an integer channel id, from 1 to 16. The `time` attribute is an integer duration of the event in ticks. This value can be zero. This value is not essential, as ultimate time positioning is determined by :class:`~music21.midi.DeltaTime` objects. The `pitch` attribute is only defined for note-on and note-off messages. The attribute stores an integer representation (0-127, with 60 = middle C). The `velocity` attribute is only defined for note-on and note-off messages. The attribute stores an integer representation (0-127). A note-on message with velocity 0 is generally assumed to be the same as a note-off message. The `data` attribute is used for storing other messages, such as SEQUENCE_TRACK_NAME string values. .. warning:: The attributes `.midiProgram` and `.midiChannel` on :class:`~music21.instrument.Instrument` objects are 0-indexed, just as they need to be in the written binary .mid. However, as a convenience, :attr:`MidiEvent.channel` is 1-indexed. No analogous convenience is provided for program change data. >>> mt = midi.MidiTrack(1) >>> me1 = midi.MidiEvent(mt) >>> me1.type = midi.ChannelVoiceMessages.NOTE_ON >>> me1.channel = 3 >>> me1.time = 200 >>> me1.pitch = 60 >>> me1.velocity = 120 >>> me1 >>> me2 = midi.MidiEvent(mt) >>> me2.type = midi.MetaEvents.SEQUENCE_TRACK_NAME >>> me2.data = 'guitar' >>> me2 Changed in v9.7 - None is not a valid type anymore. Use MetaEvents.UNKNOWN instead. Channel defaults to 1. NrrMczXlX lX0lX@lSUlSUlSUlSUlSUlgr7) tracktypetimechannel parameter1 parameter2 centShiftcorrespondingEventlastStatusByte)selfrrrrs r'__init__MidiEvent.__init__?sC &+ $(  # *.*. $( 37)-r&cUR[R:XagUR[R:Xagg)a Ensure that for MidiEvents at the same "time", that order is NOTE_OFF, PITCH_BEND, all others. >>> CVM = midi.ChannelVoiceMessages >>> noteOn = midi.MidiEvent(type=CVM.NOTE_ON) >>> noteOff = midi.MidiEvent(type=CVM.NOTE_OFF) >>> pitchBend = midi.MidiEvent(type=CVM.PITCH_BEND) >>> sorted([noteOn, noteOff, pitchBend], key=lambda me: me.sortOrder) [, , ] iir)rr rkrqrs r' sortOrderMidiEvent.sortOrderZs3" 99,55 5 YY.99 9r&c6URcSnOB[UR[5(a URnOURRn[UR[ 5(aURR nO%URcSnO[UR5nUS3nURS:waUSUR<S3- nUSU3- nUR[;dUR[;aUSUR<3- nUR[R[R4;aSS/nOURcS /nOS S /nUH1n[X5cMUS-U-S -[[X55-nM3 U$) NNone, rzt=ztrack=z , channel=pitchvelocitydatarr=)rr?r@indexrrnamereprrr r rrlrkrgetattr)r trackIndex printTyperattrListattribs r' _reprInternalMidiEvent._reprInternalrsf :: J  C ( (J))J dii . . I YY ITYYIk  99> 2dii]"% %A vj\ "" 99, , =P0P :dll-. .A 99-557K7T7TU U,H&"8(,7Ft$0Hv%+d743H.IIr&cUR[R[R4;a"URb[ UR5$gr7)rr rlrkrr@rs r'rMidiEvent.pitchs? II.668L8U8UV VOO/t' 'r&cXlgr7rrvalues r'rrr&cZ[UR[5(dgUR$r7)r?rr@rs r'rMidiEvent.velocitys $//3//r&cXlgr7)rrs r'rrrr&cUR$)z Read or set the data (`.parameter1`) for the object Does some automatic conversions: >>> me = midi.MidiEvent(type=midi.ChannelModeMessages.LOCAL_CONTROL) >>> me.data = True >>> me.data b'\x01' rrs r'rMidiEvent.datasr&cUbf[U[5(dQ[U[5(aURS5nO*[U[5(a[[ U5/5nXlg)Nzutf-8)r?r4rDencodeboolr@rrs r'rrsQ  Zu%=%=%%% W-E4((s5zl+r&cRUS-nX:aUnOUSU-:aSU-nSnSU- nUnX- nUS:a[[Xu-55nOUS:a[[Xv-55nOSnXH-n [U 5n U Sn U S-n [U 5S:a U Sn U S-n OU n Sn XlXlg) a Treat this event as a pitch bend value, and set the .parameter1 and .parameter2 fields appropriately given a specified bend value in cents. Also called Pitch Wheel The `bendRange` parameter gives the number of half steps in the bend range. >>> mt = midi.MidiTrack(1) >>> me1 = midi.MidiEvent(mt, type=midi.ChannelVoiceMessages.PITCH_BEND) >>> me1.setPitchBend(50) >>> me1.parameter1, me1.parameter2 (0, 80) >>> me1.setPitchBend(100) >>> me1.parameter1, me1.parameter2 (0, 96) Neutral is 0, 64 >>> me1.setPitchBend(0) >>> me1.parameter1, me1.parameter2 (0, 64) Parameter 2 is the most significant digit, not parameter 1. >>> me1.setPitchBend(101) >>> me1.parameter1, me1.parameter2 (40, 96) Exceeding maximum pitch bend sets the max (127, 127) >>> me1.setPitchBend(200) >>> me1.parameter1, me1.parameter2 (127, 127) >>> me1.setPitchBend(300) >>> me1.parameter1, me1.parameter2 (127, 127) >>> me1.setPitchBend(-50) >>> me1.parameter1, me1.parameter2 (0, 48) >>> me1.setPitchBend(-100) >>> me1.parameter1, me1.parameter2 (0, 32) >>> me1.setPitchBend(-196) >>> me1.parameter1, me1.parameter2 (36, 1) >>> me1.setPitchBend(-200) >>> me1.parameter1, me1.parameter2 (0, 0) Again, excess trimmed >>> me1.setPitchBend(-300) >>> me1.parameter1, me1.parameter2 (0, 0) But a larger `bendRange` can be set in semitones for non-GM devices: >>> me1.setPitchBend(-300, bendRange=4) >>> me1.parameter1, me1.parameter2 (0, 16) >>> me1.setPitchBend(-399, bendRange=4) >>> me1.parameter1, me1.parameter2 (20, 0) OMIT_FROM_DOCS Pitch bends very close to 0 formerly had problems >>> me1.setPitchBend(-196) >>> me1.parameter1, me1.parameter2 (36, 1) >>> me1.setPitchBend(-197) >>> me1.parameter1, me1.parameter2 (123, 0) dr]i i?rrLrMN)r@roundrr/rr) rcents bendRange centRangecentertopSpan bottomSpan shiftScalarshifttarget charValued1d2s r' setPitchBendMidiEvent.setPitchBendsbO  E R)^ #NEv% ' 19k345E QYk678EE,F3 q\ $Y y>A 1BdBBB r&c\[U5S:a[SU<S35eUSnUSnSn[U5S:aUSnUS-nUS-nUS-Ul[U5UlUR[R [R 4;a-US:a[S UR<S U35eX0lUSS $UR[R:XaS n[RU5(ah[U5UlUR[R:XaS nUSS:HUlO*UR[R:Xa S nUSUlU(d X0lX@lUSS $UR[R :XaX0lX@lUSS $UR[R"[R$4;aX0lX@lUSS $UR[R*:XaX0lX@lUSS $[-SUR35e)a Take a set of bytes that represent a ChannelVoiceMessage and set the appropriate event type and data, returning the remaining bytes. Channel voice messages start with a one-byte message from 0x80 to 0xEF, where the first nibble (8-E) is the message type and the second nibble (0-F) is the channel represented in hex. First let's create a MidiEvent that does not know its type. >>> mt = midi.MidiTrack(1) >>> me1 = midi.MidiEvent(mt) >>> me1 Now create two messages -- a note on (at pitch = 60 or C4) at velocity 120 >>> midBytes = bytes([0x92, 60, 120]) >>> midBytes b'\x92>> midBytes += b'hello' >>> midBytes b'\x92>> remainder = me1.parseChannelVoiceMessage(midBytes) >>> me1 The remainder would probably contain a delta time and following events, but here we'll just show that it passes whatever is left through. >>> remainder b'hello' We will ignore remainders for the rest of this demo. Note that all attributes are set properly: >>> me1.type >>> me1.pitch # 60 = middle C 60 >>> me1.velocity 120 The channel is 3 because 0x90 is NOTE_ON for channel 1, 0x91 is 2, and 0x92 is 3, etc. >>> me1.channel 3 Now let's make a program change on channel 16: >>> me2 = midi.MidiEvent(mt) >>> rem = me2.parseChannelVoiceMessage(bytes([0xCF, 71])) >>> me2 >>> me2.data # 71 = clarinet (0-127 indexed) 71 Program changes and channel pressures only go to 127. More than that signals an error: >>> me2.parseChannelVoiceMessage(bytes([0xCF, 200])) Traceback (most recent call last): music21.midi.base.MidiException: Cannot have a followed by a byte > 127: 200 r*z length of z must be at least 2rrMrrLzCannot have a z followed by a byte > 127: NFTrz"expected ChannelVoiceMessage, got )r/ ValueErrorrr rrorprrrnr hasValuer|rrrrqrlrkrrrm TypeError)rrObyte0byte1byte2 msgNybble channelNybblespecificDataSets r'parseChannelVoiceMessage"MidiEvent.parseChannelVoiceMessage?sV y>A z)6IJK K! !  y>A aLE "T\ $q( (3  99-<<-BBD Ds{#$TYYM1LUGTVVIQR= YY.@@ @#O"++E22/6 99 3 A AA&*O!*1!5DIYY"5"B"BB&*O )! DI""'"'QR= YY.99 9#O#OQR= YY/779M9V9VW WJ!MQR= YY.FF F#O#OQR= >> channel = 0x2 >>> noteOnMessage = midi.ChannelVoiceMessages.NOTE_ON | channel >>> hex(noteOnMessage) '0x92' This is how the system reads note-on messages (0x90-0x9F) and channels >>> hex(0x91 & 0xF0) # testing message type extraction '0x90' >>> hex(0x92 & 0xF0) # testing message type extraction '0x90' >>> (0x90 & 0x0F) + 1 # getting the channel 1 >>> (0x9F & 0x0F) + 1 # getting the channel 16 r*z%MidiEvent.read(): got bad data stringr&rrNNrVrrMzgot unknown midi event typezhex(midiBytes[1])zUnknown midi event type )r/ environLocal printDebugrrr4r rrr rrrrr rhexr)rrOrrunningStatusBytemsgTyperr:midiBytesAfterLengths r'readMidiEvent.reads, y>A   # #8$y/J L q\ 4<"".$)4+>+>*?$@!$+!*5IaLE d]"' t|q\ ( ( 1 100; ;  ! !% ( (#E*DI+B9QR=+Q (F,Wf5DI'0 0& &""5))&u- '.. +B9QR=+Q (F,Wf5DI'0 0  # #%BCJ%8#il:K%M N":3u:, GH Hr&c  [R(a![UR[5(deUR[ ;Ga[ URS- URR-/5nUR[ R[ R4;aURb URc [S5e[UR[5(a[ UR/5nO URn[UR[5(a[ UR/5nO URnX#-nX-$UR[ R:Xa9[UR[5(a[ UR/5nX-$[UR[5(a[ UR/5nX-$[UR[ 5(aURnX-$[!S5eUR[$;aURb[ SUR-S- /5n[ URR/5n[UR[5(a[ UR/5nO URnXV-U-$UR[&;a[UR[ 5(aj[ URR/5nU[)[+UR55-n[R,"[ UR5nXx-$UR[.;a[UR[ [045(a~[ [2/5nU[ URR/5- nU[)[+UR55- n[R,"[ UR5nXx-$[S UR<35e![ ["4a! [SUSUR<S3S-5ef=f![4[ 4aP U[6R8"S [R,"[0UR55R;S S 5-s$f=f) a Return a set of bytes for this MIDI event (used for translating from music21 to MIDI) >>> noteOn = midi.MidiEvent(type=midi.ChannelVoiceMessages.NOTE_ON, channel=10) >>> noteOn.pitch = 60 >>> noteOn.velocity = 127 >>> noteOn.getBytes() b'\x99<\x7f' Changing the pitch changes the second byte (from less than to greater than): >>> noteOn.pitch = 62 >>> noteOn.getBytes() b'\x99>\x7f' >>> ord('>') 62 Changing the velocity changes the third byte: >>> noteOn.velocity = 64 >>> noteOn.getBytes() b'\x99>@' The third byte is `\x40` but it is represented by '@' >>> ord('@') 64 >>> hex(64) '0x40' And changing the channel changes the first byte: >>> noteOn.channel = 11 >>> noteOn.getBytes() b'\x9a>@' rMz>Cannot write MIDI event without parameter1 and parameter2 set.zdata must be bytes or intzGot incorrect data for z in .data: rz"cannot parse Miscellaneous MessagerfNFKDasciiignorezunknown midi event type: )rBrCr?rrr r4rrrorprrrr@rrrr r rr/castr rDrUnicodeDecodeError unicodedata normalizer) rbytes0 param1data param2datar channelModemsgValuessys_datas r'getBytesMidiEvent.getBytessJ ??dii66 66 99, ,DLL1,tyy>?@Fyy!5!D!D!5!J!J!LL??*doo.E'X doos33!&'8!9J!%Jdoos33!&'8!9J!%J!.= 2AAAjQUQZQZ\_F`F`dii[)=  @!$))S11$dii[1= $DIIu55#yy= ((CDDYY- -$))2G !4q!8 9:Kdiioo./H$))S))dii[)yy)D0 0 YY+ %*TYY*F*Ftyy'(A+C N;;AvveTYY/H<  YY* $DIIs|)L)L'()A  () )A (TYY8 8A ,66%3|# ";DII= IJ JO":.@'1${499-rR>?@@@:' 2 , ;00FF3 *&(+,,  ,s+35P9,+P9 P97(Q-91Q*-AS  S cbUR[R:XaURS:wagg)a Return a boolean if this is a note-on message and velocity is not zero. >>> mt = midi.MidiTrack(1) >>> me1 = midi.MidiEvent(mt) >>> me1.type = midi.ChannelVoiceMessages.NOTE_ON >>> me1.velocity = 120 >>> me1.isNoteOn() True >>> me1.isNoteOff() False A zero velocity note-on is treated as a note-off: >>> me1.velocity = 0 >>> me1.isNoteOn() False >>> me1.isNoteOff() True A midi event can be neither a note on or a note off. >>> me1.type = midi.ChannelVoiceMessages.PROGRAM_CHANGE >>> me1.isNoteOn() False >>> me1.isNoteOff() False rTF)rr rlrrs r'isNoteOnMidiEvent.isNoteOns(: 99,44 4!9Kr&cUR[R:XagUR[R:XaURS:Xagg)a Return a boolean if this should be interpreted as a note-off message, either as a real note-off or as a note-on with zero velocity. >>> mt = midi.MidiTrack(1) >>> me1 = midi.MidiEvent(mt) >>> me1.type = midi.ChannelVoiceMessages.NOTE_OFF >>> me1.isNoteOn() False >>> me1.isNoteOff() True >>> me2 = midi.MidiEvent(mt) >>> me2.type = midi.ChannelVoiceMessages.NOTE_ON >>> me2.velocity = 0 >>> me2.isNoteOn() False >>> me2.isNoteOff() True See :meth:`~music21.midi.MidiEvent.isNoteOn` for more examples. TrF)rr rkrlrrs r' isNoteOffMidiEvent.isNoteOffs>. 99,55 5 YY.66 64==A;Mr&c&URS:Xagg)z Return a boolean if this is a DeltaTime subclass. >>> mt = midi.MidiTrack(1) >>> dt = midi.DeltaTime(mt) >>> dt.isDeltaTime() True rTF)rrs r' isDeltaTimeMidiEvent.isDeltaTimes 99 #r&cUR5(aJUR5(a5URUR:XaURUR:Xagg)a Returns True if `other` is a MIDI event that specifies a note-off message for this message. That is, this event is a NOTE_ON message, and the other is a NOTE_OFF message for this pitch on this channel. Otherwise returns False >>> mt = midi.MidiTrack(1) >>> me1 = midi.MidiEvent(mt) >>> me1.type = midi.ChannelVoiceMessages.NOTE_ON >>> me1.velocity = 120 >>> me1.pitch = 60 >>> me2 = midi.MidiEvent(mt) >>> me2.type = midi.ChannelVoiceMessages.NOTE_ON >>> me2.velocity = 0 >>> me2.pitch = 60 `me2` is a Note off for `me1` because it has velocity 0 and matches pitch. >>> me1.matchedNoteOff(me2) True Now the pitch does not match, so it does not work. >>> me2.pitch = 61 >>> me1.matchedNoteOff(me2) False >>> me2.type = midi.ChannelVoiceMessages.NOTE_OFF >>> me1.matchedNoteOff(me2) False >>> me2.pitch = 60 >>> me1.matchedNoteOff(me2) True Channels must match also: >>> me2.channel = 12 >>> me1.matchedNoteOff(me2) False Note that this method is no longer used in MIDI Parsing because it is inefficient. TF)rrrr)rothers r'matchedNoteOffMidiEvent.matchedNoteOffsA^ ==??u00zzU[[(T\\U]]-Jr&) rrrrrrrrrrrr)rMidiTrack | NonerMidiEventTypesrr@rr@returnr@r#rD)r# int | None)rr%)r#zint | bytes | None)rzint | str | bytes | bool | None)r*)rz int | floatr#rrOr4r#r4r#r4r#r)rrr#r)r!r"r#r$rjr rrpropertyrrrsetterrrrrrrrrrrr%r r&r'rrs6t*.(2(:(: ! -&-%-- -6."J \\   __     [[  vp~J@VIpsKlB: 2r&rch^\rSrSrSrSS U4SjjjrS U4SjjrS SjrS SjrSr U=r $) ri a A :class:`~music21.midi.MidiEvent` subclass that stores the time change (in ticks) since the start or since the last MidiEvent. Pairs of DeltaTime and MidiEvent objects are the basic presentation of temporal data. The `track` argument must be a :class:`~music21.midi.MidiTrack` object. Time values are in integers, representing ticks. The `channel` attribute, inherited from MidiEvent is not used and set to None unless overridden (it does not do anything if set and is not written out to MIDI). >>> mt = midi.MidiTrack(1) >>> dt = midi.DeltaTime(mt) >>> dt.time = 1 >>> dt Changed in v9.7 -- DeltaTime repr no longer lists its channel (to de-emphasize it). Channel defaults to 1. c0>[TU]XUS9 SUlg)N)rrr)superrr)rrrr __class__s r'rDeltaTime.__init__$s 7; r&cr>[TU]5nURSS5nURS:XaSU-nU$)Nz 'DeltaTime', rz(empty) )r-rreplacer)rrepr.s r'rDeltaTime._reprInternal-s:g#%kk/2. 99>s"C r&cD[U5uUlnURU4$)a Read a byte-string until hitting a character below 0x80 and return the converted number and the rest of the bytes. The first number is also stored in `self.time`. >>> mt = midi.MidiTrack(1) >>> dt = midi.DeltaTime(mt) >>> dt.time 0 >>> dt.readUntilLowByte(b'\x20') (32, b'') >>> dt.time 32 >>> dt.readUntilLowByte(b'\x20hello') (32, b'hello') here the '\x82' is above 0x80 so the 'h' is read as part of the continuation. >>> dt.readUntilLowByte(b'\x82hello') (360, b'ello') Changed in v9: had an incompatible signature with MidiEvent )rr)roldBytesnewBytess r'readUntilLowByteDeltaTime.readUntilLowByte4s$86h? 8yy(""r&c0[UR5nU$)a* Convert the time integer into a set of bytes. >>> mt = midi.MidiTrack(1) >>> dt = midi.DeltaTime(mt) >>> dt.time = 1 >>> dt.getBytes() b'\x01' >>> dt.time = 128 >>> dt.getBytes() b'\x81\x00' >>> dt.time = 257 >>> dt.getBytes() b'\x82\x01' >>> dt.time = 16385 >>> dt.getBytes() b'\x81\x80\x01' )rr)rrOs r'rDeltaTime.getBytesSs,,DII6 r&)rr)NrrM)rr rr@rr@r$)r6r4r#tuple[int, bytes]r') r!r"r#r$rjrrr8rr% __classcell__)r.s@r'rr sM0!%       #>r&c\rSrSrSrSrSSSjjrSSjr\SSj5r SSjr SSSjjr SS jr S r SS jrSS jrSS jrSSjrSSjrSrg)rima A MIDI Track. Each track contains an index and a list of events. All events are stored in the `events` list, in order. An `index` is an integer identifier for this object. It is often called "trackId" though technically the id for a MidiTrack is always b'MTrk' >>> mt = midi.MidiTrack(index=3) >>> mt.events [] >>> mt.index 3 The data consists of all the midi data after b'MTrk' >>> mt.data b'' And the .length is the same as the data's length >>> mt.length 0 After reading a string >>> mt.read(b'MTrk\x00\x00\x00\x16\x00\xff\x03\x00\x00' ... + b'\xe0\x00@\x00\x90CZ\x88\x00\x80C\x00\x88\x00\xff/\x00') b'' The returned value is what is left over after the track is read (for instance the data for another track) >>> mt.length 22 New in v9.7: len(mt) returns the same as mt.length, but more Pythonic. >>> len(mt) 22 >>> mt.data[:8] b'\x00\xff\x03\x00\x00\xe0\x00@' Note that the '\x16' got translated to ascii '@'. >>> mt.events [, , , , , , , , , ] >>> mt There is a class attribute of the headerId which is the same for all MidiTrack objects >>> midi.MidiTrack.headerId b'MTrk' sMTrkc,Xl/UlSUlg)Nr&)reventsr)rrs r'rMidiTrack.__init__s ')  r&c,[UR5$)z New in v9.7 r/rrs r'__len__MidiTrack.__len__s499~r&c,[UR5$r7rCrs r'r:MidiTrack.lengths499~r&cUSSUR:Xd [S5e[USSS5up!USUnX0lXSnUR U5 U$)a Read as much of the bytes object (representing midi data) as necessary; return the remaining bytes object for reassignment and further processing. The string should begin with `MTrk`, specifying a Midi Track Stores the read data (after the header and length information) in self.data Calls `processDataToEvents` which creates :class:`~music21.midi.DeltaTime` and :class:`~music21.midi.MidiEvent` objects and stores them in self.events Nrz.badly formed midi string: missing leading MTrk)headerIdrrrprocessDataToEvents)rrOr: trackData remainders r'rMidiTrack.readsh!} - PQ Q%imQ7gv&  g&    +r&cfSnSnU(a[US9nURU5upVX%-n[US9nUbURUlUR U5nUnUR RU5 UR RU5 UnU(aMgg![ a UnMf=f)z5 Populate .events with trackData. Called by .read() rN)r)rr8rrrrr@rR) rrKrpreviousMidiEventdelta_tdttrackDataCandidate timeCandidate midiEvents r'rJMidiTrack.processDataToEventss,0 d+G%,%=%=i%H "B IM"-I ,+<+K+K ( %NN+=> $ KK  w ' KK  y ) ) 7i"! /   s B B0/B0c @/nURH#nURUR55 M% SR U5nUR[[U5S5-U-$![a'n[R SUSUS35 SnAMSnAff=f)az Returns bytes of midi-data from the `.events` in the object. For conversion from music21 to MIDI. For example: two events, one note-on and one note-off on C4 which appears as "<" in the data. >>> mt = midi.MidiTrack(index=2) >>> dt1 = midi.DeltaTime(mt, time=0) >>> noteOn = midi.MidiEvent(mt, type=midi.ChannelVoiceMessages.NOTE_ON, channel=3) >>> noteOn.pitch = 60 >>> noteOn.velocity = 20 >>> dt2 = midi.DeltaTime(mt, time=1030) >>> noteOff = midi.MidiEvent(mt, type=midi.ChannelVoiceMessages.NOTE_OFF, channel=3) >>> noteOff.pitch = 60 >>> noteOff.velocity = 0 >>> mt.events = [dt1, noteOn, dt2, noteOff] >>> bytes = mt.getBytes() >>> bytes b'MTrk\x00\x00\x00\t\x00\x92<\x14\x88\x06\x82<\x00' Explanation: The first four bytes `MTrk` are the header for any MIDI Track >>> bytes[:4] b'MTrk' The next four bytes are the length of the data in bytes, the final `b'\t'` indicates there are 9 bytes to follow. >>> midi.base.getNumber(bytes[4:8], 4) (9, b'') The next byte is an empty delta time event. >>> bytes[8] 0 The next three bytes are the note-on event. >>> noteOn2 = midi.MidiEvent() >>> _ = noteOn2.parseChannelVoiceMessage(bytes[9:12]) >>> noteOn2 Followed by two bytes for the DeltaTime of 1030 ticks. >>> dt3 = midi.DeltaTime() >>> dt3.readUntilLowByte(bytes[12:14]) (1030, b'') The 1030 is stored as b'\x88\x06' where the first byte is 136 and the second 6, but MIDI stores each continuing digit as the last 7 bits of a 8-bit number with first bit 1, so we remove the first bit by subtracting 128: 136 - 128 = 8. Then we multiply 8 by 128 to get 1024 and add 6 to get 1030. Finally, the last three bytes are the note-off event. >>> noteOff2 = midi.MidiEvent() >>> _ = noteOff2.parseChannelVoiceMessage(bytes[14:]) >>> noteOff2 zConversion error for z: z ; ignored.Nr&r) r@rRrrrwarnjoinrIrr/)rrOrTex bytes_outs r'rMidiTrack.getBytessJ"$ I W  !3!3!56%HHY' }}yY;;iGG ! W!!$9)Brd*"UVV WsA,, B6BBcPURS[UR5S3nU$)Nz -- z events)rr/r@)rrs r'rMidiTrack._reprInternalUs'zzl$s4;;/0 8r&c6URH nXlM g)a5 We may attach events to this track before setting their `track` parameter. This method will move through all events and set their track to this track. >>> mt = midi.MidiTrack(index=2) >>> noteOn = midi.MidiEvent(type=midi.ChannelVoiceMessages.NOTE_ON, channel=1) >>> noteOn.pitch = 60 >>> noteOn.velocity = 20 >>> noteOn >>> mt.events = [noteOn] >>> mt.updateEvents() >>> noteOn >>> noteOn.track is mt True N)r@rres r' updateEventsMidiTrack.updateEventsZs&AGr&cXURHnUR5(dM g g)z Return True/False if this track has any note-ons defined. >>> mt = midi.MidiTrack(index=2) >>> mt.hasNotes() False >>> noteOn = midi.MidiEvent(type=midi.ChannelVoiceMessages.NOTE_ON, channel=1) >>> mt.events = [noteOn] >>> mt.hasNotes() True TF)r@rr_s r'hasNotesMidiTrack.hasNotesps%Azz||r&crU[SS5;a[SU35eURH nXlM g)a Set the one-indexed channel of all events in this Track. >>> mt = midi.MidiTrack(index=2) >>> noteOn = midi.MidiEvent(type=midi.ChannelVoiceMessages.NOTE_ON, channel=1) >>> mt.events = [noteOn] >>> mt.setChannel(11) >>> noteOn.channel 11 Channel must be a value from 1-16 >>> mt.setChannel(22) Traceback (most recent call last): music21.midi.base.MidiException: bad channel value: 22 rMzbad channel value: N)rArr@r)rrr`s r' setChannelMidiTrack.setChannels8" a $"5eW => >AIr&c[5nURH-nURcMURUR5 M/ [ U5$)a Get all channels (excluding None) used in this Track (sorted) >>> mt = midi.MidiTrack(index=2) >>> noteOn = midi.MidiEvent(type=midi.ChannelVoiceMessages.NOTE_ON, channel=14) >>> noteOn2 = midi.MidiEvent(type=midi.ChannelVoiceMessages.NOTE_ON, channel=5) >>> noteOn3 = midi.MidiEvent(type=midi.ChannelVoiceMessages.NOTE_ON, channel=14) >>> noteOn4 = midi.MidiEvent(type=midi.ChannelVoiceMessages.PROGRAM_CHANGE, channel=None) >>> mt.events = [noteOn, noteOn2, noteOn3, noteOn4] >>> mt.getChannels() [5, 14] )setr@raddsortedrrSr`s r' getChannelsMidiTrack.getChannelss?Ayy$#d|r&c /nURHqnUR[R:XdM#[ UR [ 5(dMDUR U;dMVURUR 5 Ms U$)a Get all unique program changes used in this Track, in order they appear. >>> mt = midi.MidiTrack(index=2) >>> pc1 = midi.MidiEvent(type=midi.ChannelVoiceMessages.PROGRAM_CHANGE) >>> pc1.data = 14 >>> noteOn = midi.MidiEvent(type=midi.ChannelVoiceMessages.NOTE_ON, channel=14) >>> pc2 = midi.MidiEvent(type=midi.ChannelVoiceMessages.PROGRAM_CHANGE) >>> pc2.data = 1 >>> mt.events = [pc1, noteOn, pc2] >>> mt.getProgramChanges() [14, 1] )r@rr ror?rr@rRrns r'getProgramChangesMidiTrack.getProgramChangess^A.==="1663//d* AFF#   r&)rr@rN)r)rr@r"r&)r&)rKr4r#rr'r#rr()rr@r#r)r# list[int])r!r"r#r$rjrIrrDr)r:rrJrrrardrhrorrr%r r&r'rrms_BFH  6&*PNH` ,&,*r&rc\rSrSrSrSrSSjrSSSjjrSSjrSSjr SSjr SS jr SS jr SS jr SS jrSS jrSrg)ria Low-level MIDI file writing, emulating methods from normal Python files. For most users, do not go here, simply use: score = converter.parse('path/to/file/in.mid') midi_out = score.write('midi', fp='path/to/file/out.mid') The `ticksPerQuarterNote` attribute must be set before writing. 1024 is a common value. This object is returned by some properties for directly writing files of midi representations. >>> mf = midi.MidiFile() >>> mf Music21 can read format 0 and format 1, and writes format 1. Format 2 files are not parsable. >>> mf.format 1 After loading or before writing, tracks are stored in this list. >>> mf.tracks [] Most midi files store `ticksPerQuarterNote` and not `ticksPerSecond` >>> mf.ticksPerQuarterNote 10080 >>> mf.ticksPerSecond is None True All MidiFiles have the same `headerId` >>> midi.MidiFile.headerId b'MThd' MThdcfSUlSUl/Ul[RUlSUlg)NrM)fileformattracksrticksPerQuarterticksPerQuarterNoteticksPerSecondrs r'rMidiFile.__init__s-%)  ') (0(@(@ (,r&cUS;a [SU5e[R"[R[ X55Ulg)ze Open a MIDI file path for reading or writing. For writing to a MIDI file, `attrib` should be "wb". )rbwbz0cannot read or write unless in binary mode, not:N)rrBrBinaryIOopenry)rfilenamers r'r MidiFile.opens6  % RTZ[ [FF1::tH'=> r&cXlg)z Assign a file-like object, such as those provided by BytesIO, as an open file object. >>> from io import BytesIO >>> fileLikeOpen = BytesIO() >>> mf = midi.MidiFile() >>> mf.openFileLike(fileLikeOpen) >>> mf.close() N)ry)rfileLikes r' openFileLikeMidiFile.openFileLikes  r&cN[UR5nUS:waSOSnUSU3$)NrMrr1z track)r/r{)r lenTracksplurals r'rMidiFile._reprInternals. $ !QBF6(++r&c\UR(dgURR5 g)z Close the file. N)ryclosers r'rMidiFile.closesyy  r&cUR(d [S5eURURR55 g)z, Read and parse MIDI data stored in a file. No file is open.N)ryrreadstrrrs r'r MidiFile.reads.yy./ / TYY^^%&r&c0USSS:Xd[SUSS<35e[USSS5up!US:wa [S5e[US5up1X0lUS ;a[S [35e[US5upA[US5upQUS -(a4US - S -*nUS-nUS;a[SU35eUS:XaSnXv-UlO US-Ul[ U5H:n[ U5n U RU5nURRU 5 M< g)z Read and parse MIDI data as a bytes, putting the data in `.ticksPerQuarterNote` and a list of `MidiTrack` objects in the attribute `.tracks`. The name readstr is a carryover from Python 2. It works on bytes objects, not strings Nrrwz!badly formatted midi bytes, got: rzbadly formatted midi bytesr*)rrMz cannot handle midi file format: r+irV)zcannot handle ticks per frame: rri) rrrzr~r}rArrr{rR) rrOr:midiFormatType numTracksdivisionframesPerSecond ticksPerFramerFtrks r'rMidiFile.readstr&sB!}'"CIcrNCU VW W&imQ7 Q; <= =$-i$;!$  '"B6( KL L(A6 ' 15 f !)Q% 78O$tOM$44#&Em_$UVV" " "/"AD '/&'8D $ y!AA,C+I KK  s #"r&cUR(d [S5eUR5nURRU5 g)z> Write MIDI data as a file to the file opened with `.open()`. rN)ryrwritestrwrite)rwss r'rMidiFile.writeUs2yy./ / ]]_ r&cpUR5nURHnXR5-nM U$)z Generate the MIDI data header and convert the list of MidiTrack objects in self.tracks into MIDI data and return it as bytes. The name `writestr` is a carry-over from Python 2. It works on bytes, not strings. ) writeMThdStrr{r)rrOrs r'rMidiFile.writestr_s4%%' ;;C!LLN2Ir&cURnUS-S:wa [S5eUR[SS5-[URS5-nU[[ UR 5S5-nU[US5-nU$)z Convert the information in self.ticksPerQuarterNote into MIDI data header and return it as bytes. The name `writeMThdStr` is a carry-over from Python 2. It works on bytes, not strings. rrzMCannot write midi bytes unless self.ticksPerQuarterNote is a multiple of 1024rrr*)r}rrIrrzr/r{)rrrOs r'rMidiFile.writeMThdStrks++ v ! #_a aMMIaO3i Q6OO  #dkk*:A >>  (A 66 r&)ryrzr}r~r{Nrt)r)rz t.BinaryIOr#rr$)rOr4r#rr')r!r"r#r$rjrIrrrrrrrrrrr%r r&r'rrsB&NH- ? , '-$^ r&rz list[type] _DOC_ORDER__main__)r0rD)r5 Iterable[int]r#r4)r9r@r:r@r#ztuple[int, int])r9rDr:r@r#ztuple[int, str])r9r4r:r@r#r<)r9zstr | bytes | intr:r@r#ztuple[int, str | bytes | int])rOr4r#r<)rOzbytes | Iterable[int]r#ru)rXr@r:r@r#r4)rPr@r#r4)rbrr#r4)/rj __future__r__all__collections.abcrrtypingrrBmusic21rmusic21.common.enumsrrrrr EnvironmentrMusic21Exceptionr deprecatedr rrrrrrrr r r r rLiteralr!ProtoM21Objectrrrrr__annotations__r!mainTestr r&r'rs# %- &&{3  L11 65"?@A*65"?@A$      >#B<?~65"?@A6:bJ,^ < ,6, ii  E &&E P] ]@V&&Vr tw%%tr$Y 8D JD z r&