jyUddlmZddlZddlZddlZddlZddlmZddlmZddlm Z ddlm Z ddlm Z ddlm Z dd l mZdd l mZdd l mZdd l mZd ZddiZded<GddZGddeZ d&d'dZdZdZd(dZd(d ZGd!d"e jZGd#d$ejZe d%krddlZej!edSdS))) annotationsN)chord) environment) exceptions21)note)pitch)scale) possibility) realizerScale) resolution)ruleszfiguredBass.segmentr z0dict[str, realizerScale.FiguredBassScale | None]_defaultRealizerScaleceZdZUgdZdddddddZd ed < d(d)dZd*dZd*dZd*dZ dZ d+dZ d Z d!Z d"Zd#Zd$Zd%Zd&Zd'Zd S),Segment) allSinglePossibilitiessinglePossibilityRulesallCorrectSinglePossibilitiesconsecutivePossibilityRulesspecialResolutionRules"allCorrectConsecutivePossibilitiesresolveDominantSeventhSegmentresolveDiminishedSeventhSegmentresolveAugmentedSixthSegmentzZA :class:`~music21.note.Note` whose pitch forms the bass of each possibility.zThe number of parts (including the bass) that possibilities should contain, which comes directly from :attr:`~music21.figuredBass.rules.Rules.numParts` in the Rules object.zA list of allowable pitch names. This is derived from bassNote.pitch and notationString using :meth:`~music21.figuredBass.realizerScale.FiguredBassScale.getPitchNames`.a|A list of allowable pitches in the upper parts of a possibility. This is derived using :meth:`~music21.figuredBass.segment.getPitches`, providing bassNote.pitch, :attr:`~music21.figuredBass.rules.Rules.maxPitch` from the Rules object, and :attr:`~music21.figuredBass.segment.Segment.pitchNamesInChord` as arguments.z}:attr:`~music21.figuredBass.segment.Segment.allPitchesAboveBass` represented as a :class:`~music21.chord.Chord`.zLA deepcopy of the :class:`~music21.figuredBass.rules.Rules` object provided.)bassNotenumPartspitchNamesInChordallPitchesAboveBass segmentChordfbRuleszdict[str, str] _DOC_ATTRC3NB5rstr | note.NotenotationString str | NonefbScale%realizerScale.FiguredBassScale | Nonerrules.Rules | NonemaxPitchstr | pitch.Pitchct|trtj|}t|trt j|}|5t dtjt d<t d}|J|tj |_ ntj ||_ d|_d|_d|_||_||_||_| |||_n%||jj||_t-|j|jj|j|_t1j|j|j|_t9jt<|_dS)aV A Segment corresponds to a 1:1 realization of a bassNote and notationString of a :class:`~music21.figuredBass.realizer.FiguredBassLine`. It is created by passing six arguments: a :class:`~music21.figuredBass.realizerScale.FiguredBassScale`, a bassNote, a notationString, a :class:`~music21.figuredBass.rules.Rules` object, a number of parts and a maximum pitch. Realizations of a Segment are represented as possibility tuples (see :mod:`~music21.figuredBass.possibility` for more details). Methods in Python's `itertools` module are used extensively. Methods which generate possibilities or possibility progressions return iterators, which are turned into lists in the examples for display purposes only. if fbScale is None, a realizerScale.FiguredBassScale() is created if fbRules is None, a rules.Rules() instance is created. Each Segment gets its own deepcopy of the one given. Here, a Segment is created using the default values: a FiguredBassScale in C, a bassNote of C3, an empty notationString, and a default Rules object. >>> from music21.figuredBass import segment >>> s1 = segment.Segment() >>> s1.bassNote >>> s1.numParts 4 >>> s1.pitchNamesInChord ['C', 'E', 'G'] >>> [str(p) for p in s1.allPitchesAboveBass] ['C3', 'E3', 'G3', 'C4', 'E4', 'G4', 'C5', 'E5', 'G5'] >>> s1.segmentChord Nr ) quarterLength) isinstancestrrNoterPitchrr FiguredBassScaler Rulesrcopydeepcopy_specialResolutionRuleChecking_singlePossibilityRuleChecking#_consecutivePossibilityRuleCheckingrr _maxPitchr getPitchNames getPitchesrrChordr-rr Environment_MOD _environRules)selfrr%r'rrr* listOfPitchess /Users/tedpeters/Documents/Projects/Claude Projects/Misc Tools/notename-sheets/.venv/lib/python3.11/site-packages/music21/figuredBass/segment.py__init__zSegment.__init__BsoZ h $ $ +y**H h $ $ -{8,,H ?$W-51>1O1Q1Q%g.+G4G""" ? ;==DLL=11DL.2+.2+370    !  !m&?%2D " "&-%:%:4=;NP^%_%_D "#-d.D.2m.A.2n$>$> "K(@6>6LNNN(4T::c|tj}|jtjd|jgfdtjd|jgf|jtj dfg}|S)a A framework for storing single possibility rules and methods to be applied in :meth:`~music21.figuredBass.segment.Segment.allCorrectSinglePossibilities`. Takes in a :class:`~music21.figuredBass.rules.Rules` object, fbRules. If None then a new rules object is created. Items are added within this method in the following form: (willRunOnlyIfTrue, methodToRun, keepSolutionsWhichReturn, optionalArgs) These items are compiled internally when :meth:`~music21.figuredBass.segment.Segment.allCorrectSinglePossibilities` is called on a Segment. Here, the compilation of rules and methods bases on a default fbRules is shown. >>> from music21.figuredBass import segment >>> segmentA = segment.Segment() >>> allSingleRules = segmentA.singlePossibilityRules() >>> segment.printRules(allSingleRules) Will run: Method: Keep solutions which return: Arguments: True isIncomplete False ['C', 'E', 'G'] True upperPartsWithinLimit True 12 True voiceCrossing False None Here, a modified fbRules is provided, which allows for incomplete possibilities. >>> from music21.figuredBass import rules >>> fbRules = rules.Rules() >>> fbRules.forbidIncompletePossibilities = False >>> allSingleRules = segmentA.singlePossibilityRules(fbRules) >>> segment.printRules(allSingleRules) Will run: Method: Keep solutions which return: Arguments: False isIncomplete False ['C', 'E', 'G'] True upperPartsWithinLimit True 12 True voiceCrossing False None NFT) r r3forbidIncompletePossibilitiesr isIncompleterupperPartsWithinLimitupperPartsMaxSemitoneSeparationforbidVoiceCrossing voiceCrossing)r@rsinglePossibRuless rBrzSegment.singlePossibilityRulessvL ?kmmG 2)() +29: < (*   ! rDc|tj}|j}dtjd|jgf|jtjdf|j tj dfdtj d|j gf|j tjdf|jtjdf|jtjdf|jtjdf|jo|tjdt/|j|jgfg }|S)a A framework for storing consecutive possibility rules and methods to be applied in :meth:`~music21.figuredBass.segment.Segment.allCorrectConsecutivePossibilities`. Takes in a :class:`~music21.figuredBass.rules.Rules` object, fbRules; if None then a new rules.Rules() object is created. Items are added within this method in the following form: (willRunOnlyIfTrue, methodToRun, keepSolutionsWhichReturn, optionalArgs) These items are compiled internally when :meth:`~music21.figuredBass.segment.Segment.allCorrectConsecutivePossibilities` is called on a Segment. Here, the compilation of rules and methods bases on a default fbRules is shown. >>> from music21.figuredBass import segment >>> segmentA = segment.Segment() >>> allConsecutiveRules = segmentA.consecutivePossibilityRules() >>> segment.printRules(allConsecutiveRules) Will run: Method: Keep solutions which return: Arguments: True partsSame True [] False upperPartsSame True None True voiceOverlap False None True partMovementsWithinLimits True [] True parallelFifths False None True parallelOctaves False None True hiddenFifth False None True hiddenOctave False None False couldBeItalianA6Resolution True [, , , ], True Now, a modified fbRules is provided, allowing hidden octaves and voice overlap, and limiting the soprano line to stepwise motion. >>> from music21.figuredBass import rules >>> fbRules = rules.Rules() >>> fbRules.forbidVoiceOverlap = False >>> fbRules.forbidHiddenOctaves = False >>> fbRules.partMovementLimits.append((1, 2)) >>> allConsecutiveRules = segmentA.consecutivePossibilityRules(fbRules) >>> segment.printRules(allConsecutiveRules) Will run: Method: Keep solutions which return: Arguments: True partsSame True [] False upperPartsSame True None False voiceOverlap False None True partMovementsWithinLimits True [(1, 2)] True parallelFifths False None True parallelOctaves False None True hiddenFifth False None False hiddenOctave False None False couldBeItalianA6Resolution True [, , , ], True NTF)r r3risItalianAugmentedSixthr partsSame _partsToCheck_upperPartsRemainSameupperPartsSameforbidVoiceOverlap voiceOverlappartMovementsWithinLimitspartMovementLimitsforbidParallelFifthsparallelFifthsforbidParallelOctavesparallelOctavesforbidHiddenFifths hiddenFifthforbidHiddenOctaves hiddenOctaveresolveAugmentedSixthProperlycouldBeItalianA6Resolution _unpackTriad&restrictDoublingsInItalianA6Resolution)r@rrNconsecutivePossibRuless rBrz#Segment.consecutivePossibilityRulessx ?kmmG"&"3"K"K"M"M;($1F0G H  *K,F M  ')A5 I ;8$A[@\ ]  );+Eu M  *K,G O  ')@% H  (+*BE J  2 N7N6d/00'2`a c " &%rDc2|tj}|j}|j}|j}|jo||jf|jo||j |j gf|j o||j fg}|S)a2 A framework for storing methods which perform special resolutions on Segments. Unlike the methods in :meth:`~music21.figuredBass.segment.Segment.singlePossibilityRules` and :meth:`~music21.figuredBass.segment.Segment.consecutivePossibilityRules`, these methods deal with the Segment itself, and rely on submethods to resolve the individual possibilities accordingly depending on what the resolution Segment is. If fbRules is None, then a new rules.Rules() object is created. Items are added within this method in the following form: (willRunOnlyIfTrue, methodToRun, optionalArgs) These items are compiled internally when :meth:`~music21.figuredBass.segment.Segment.allCorrectConsecutivePossibilities` is called on a Segment. Here, the compilation of rules and methods based on a default fbRules is shown. >>> from music21.figuredBass import segment >>> segmentA = segment.Segment() >>> allSpecialResRules = segmentA.specialResolutionRules() >>> segment.printRules(allSpecialResRules, maxLength=3) Will run: Method: Arguments: False resolveDominantSeventhSegment None False resolveDiminishedSeventhSegment False False resolveAugmentedSixthSegment None Dominant Seventh Segment: >>> segmentA = segment.Segment(bassNote=note.Note('B2'), notationString='6,5') >>> allSpecialResRules = segmentA.specialResolutionRules() >>> segment.printRules(allSpecialResRules, maxLength=3) Will run: Method: Arguments: True resolveDominantSeventhSegment None False resolveDiminishedSeventhSegment False False resolveAugmentedSixthSegment None Fully-Diminished Seventh Segment: >>> segmentA = segment.Segment(bassNote=note.Note('B2'), notationString='-7') >>> allSpecialResRules = segmentA.specialResolutionRules() >>> segment.printRules(allSpecialResRules, maxLength=3) Will run: Method: Arguments: False resolveDominantSeventhSegment None True resolveDiminishedSeventhSegment False False resolveAugmentedSixthSegment None Augmented Sixth Segment: >>> segmentA = segment.Segment(bassNote=note.Note('A-2'), notationString='#6,b5') >>> allSpecialResRules = segmentA.specialResolutionRules() >>> segment.printRules(allSpecialResRules, maxLength=3) Will run: Method: Arguments: False resolveDominantSeventhSegment None False resolveDiminishedSeventhSegment False True resolveAugmentedSixthSegment None ) r r3risDominantSeventhisDiminishedSeventhisAugmentedSixthresolveDominantSeventhProperlyr resolveDiminishedSeventhProperlyrdoubledRootInDim7r_r)r@rrerfrgspecialResRuless rBrzSegment.specialResolutionRules"sx ?kmmG -??AA"/CCEE,==?? 3 I8I  / 1  5 M:M4*+ - 2 G7G1 3  rDc|j}|stdt|}t j|}|}|}| d}| d}| d} |j} | dk} | } | o| dk} | dkrV| j |j kr4| s| r d|j_| j |j ko| t"j| |gf| j |j ko| t"j| |gf| j |j ko| o| dkt"j|gf| j | j ko| o| dkt"j|gf| j |j ko| o| dkt"j|gf| j |j ko| o| dkt"j|gfg} |||S#t$r2|jd||cYSwxYw) aP Can resolve a Segment whose :attr:`~music21.figuredBass.segment.Segment.segmentChord` spells out a dominant seventh chord. If no applicable method in :mod:`~music21.figuredBass.resolution` can be used, the Segment is resolved as an ordinary Segment. >>> from music21.figuredBass import segment >>> segmentA = segment.Segment(bassNote=note.Note('G2'), notationString='7') >>> allDomPossib = segmentA.allCorrectSinglePossibilities() >>> allDomPossibList = list(allDomPossib) >>> len(allDomPossibList) 8 >>> allDomPossibList[2] (, , , ) >>> allDomPossibList[5] (, , , ) Here, the Soprano pitch of resolution (C6) exceeds default maxPitch of B5, so it's filtered out. >>> [p.nameWithOctave for p in allDomPossibList[7]] ['B5', 'F5', 'D5', 'G2'] >>> segmentB = segment.Segment(bassNote=note.Note('C3'), notationString='') >>> domResPairs = segmentA.resolveDominantSeventhSegment(segmentB) >>> domResPairsList = list(domResPairs) >>> len(domResPairsList) 7 >>> domResPairsList[2] ((, <...B3>, <...F3>, <...G2>), (<...C4>, <...C4>, <...E3>, <...C3>)) >>> domResPairsList[5] ((<...D5>, <...B4>, <...F4>, <...G2>), (<...C5>, <...C5>, <...E4>, <...C3>)) zCH  :]]__ !UZ / KH4I4I4K4K  3l + -]]__ !UZ / KH4I4I4K4K6. 0mmoo"m&88$''))$!#;  mmoo"m&88&))++& A%;  mmoo"k&66&))++& A%<  mmoo"k&66&))++& A%<  -% !: :..x9RSS S : : :   # #3 4 4 4//99 9 9 9  :sL559M10M1Fc|j}|stdt|}t jd|}|}| d}|j}| dkr5| dkrd}n| dkrd}|j |j ko| tj||gf|j |j ko|tj||gf|j |j ko| tj|gf|j |j ko|tj|gfg} ||| S#t$r2|jd||cYSwxYw) a Can resolve a Segment whose :attr:`~music21.figuredBass.segment.Segment.segmentChord` spells out a diminished seventh chord. If no applicable method in :mod:`~music21.figuredBass.resolution` can be used, the Segment is resolved as an ordinary Segment. >>> from music21.figuredBass import segment >>> segmentA = segment.Segment(bassNote=note.Note('B2'), notationString='b7') >>> allDimPossib = segmentA.allCorrectSinglePossibilities() >>> allDimPossibList = list(allDimPossib) >>> len(allDimPossibList) 7 >>> [p.nameWithOctave for p in allDimPossibList[4]] ['D5', 'A-4', 'F4', 'B2'] >>> [p.nameWithOctave for p in allDimPossibList[6]] ['A-5', 'F5', 'D5', 'B2'] >>> segmentB = segment.Segment(bassNote=note.Note('C3'), notationString='') >>> dimResPairs = segmentA.resolveDiminishedSeventhSegment(segmentB) >>> dimResPairsList = list(dimResPairs) >>> len(dimResPairsList) 7 >>> dimResPairsList[4] ((<...D5>, <...A-4>, <...F4>, <...B2>), (<...E5>, <...G4>, <...E4>, <...C3>)) >>> dimResPairsList[6] ((<...A-5>, <...F5>, <...D5>, <...B2>), (<...G5>, <...E5>, <...E5>, <...C3>)) z@Diminished seventh resolution: Not a diminished seventh Segment.r"rorTFz]Diminished seventh resolution: No proper resolution available. Executing ordinary resolution.)rrfrprqr HarmonicMinorScalederiveByDegreerxrurvrwryrzr diminishedSeventhToMajorTonicr{diminishedSeventhToMinorTonic#diminishedSeventhToMajorSubdominant#diminishedSeventhToMinorSubdominantrr?rr) r@r doubledRootdimChord dimChordInfodimScalerrrdiminishedResolutionMethodss rBrz'Segment.resolveDiminishedSeventhSegmentsN:$++-- T"RTT T*844 +--< ]]__ ![%5 5 Q(:O:O:Q:Q>  ' # :..x9TUU U : : :   # #3 4 4 4//99 9 9 9  :sH9IIc|j}|std|r||S|rd}n]|rd}nF|rd}n/|j d||Stj | d}tj|}|j}t|}|dko5|j|jko|tj||gf|dko5|j|jko|tj||gf|dj| jko|tj||gfg} |||S#t$r2|j d||cYSwxYw) a Can resolve a Segment whose :attr:`~music21.figuredBass.segment.Segment.segmentChord` spells out a French, German, or Swiss augmented sixth chord. Italian augmented sixth Segments are solved as an ordinary Segment using :meth:`~music21.figuredBass.possibility.couldBeItalianA6Resolution`. If no applicable method in :mod:`~music21.figuredBass.resolution` can be used, the Segment is resolved as an ordinary Segment. >>> from music21.figuredBass import segment >>> segmentA = segment.Segment(bassNote=note.Note('A-2'), notationString='#6,b5,3') >>> segmentA.pitchNamesInChord # spell out a Gr+6 chord ['A-', 'C', 'E-', 'F#'] >>> allAugSixthPossib = segmentA.allCorrectSinglePossibilities() >>> allAugSixthPossibList = list(allAugSixthPossib) >>> len(allAugSixthPossibList) 7 >>> allAugSixthPossibList[1] (, , <...E-3>, <...A-2>) >>> allAugSixthPossibList[4] (, , <...E-4>, <...A-2>) >>> segmentB = segment.Segment(bassNote=note.Note('G2'), notationString='') >>> allAugResPossibPairs = segmentA.resolveAugmentedSixthSegment(segmentB) >>> allAugResPossibPairsList = list(allAugResPossibPairs) >>> len(allAugResPossibPairsList) 7 >>> allAugResPossibPairsList[1] ((<...C4>, <...F#3>, <...E-3>, <...A-2>), (<...B3>, <...G3>, <...D3>, <...G2>)) >>> allAugResPossibPairsList[4] ((<...C5>, <...F#4>, <...E-4>, <...A-2>), (<...B4>, <...G4>, <...D4>, <...G2>)) z;Augmented sixth resolution: Not an augmented sixth Segment.rornz^Augmented sixth resolution: Augmented sixth type not supported. Executing ordinary resolution.M3zZAugmented sixth resolution: No proper resolution available. Executing ordinary resolution.)rrgrprNrisFrenchAugmentedSixthisGermanAugmentedSixthisSwissAugmentedSixthr?rr _transposebassr rrrqrwrxryrzaugmentedSixthToMajorTonicr{augmentedSixthToMinorTonicrvaugmentedSixthToDominantr) r@r augSixthChord augSixthTyper majorScaleraugSixthChordInfoaugmentedSixthResolutionMethodss rBrz$Segment.resolveAugmentedSixthSegmentsJ) --// b"#`aa a  0 0 2 2 ://99 9  1 1 3 3 :LL  1 1 3 3 :LL  0 0 2 2 :LL   # #W X X X//99 9%m&8&8&:&:DAA%e,, (/ >>  ""a',MMOO(EJ6,))++  2\CT4U W  ""a',MMOO(EJ6,))++501  3 ((++0HMMOO4HH,))++301 3+ '  :..x9XYY Y : : :   # #3 4 4 4//99 9 9 9  :s+I9I=<I=c|jg|jdz z}|tj|jjjgtj|S)a Returns an iterator through a set of naive possibilities for a Segment, using :attr:`~music21.figuredBass.segment.Segment.numParts`, the pitch of :attr:`~music21.figuredBass.segment.Segment.bassNote`, and :attr:`~music21.figuredBass.segment.Segment.allPitchesAboveBass`. >>> from music21.figuredBass import segment >>> segmentA = segment.Segment() >>> allPossib = segmentA.allSinglePossibilities() >>> allPossib.__class__ <... 'itertools.product'> The number of naive possibilities is always the length of :attr:`~music21.figuredBass.segment.Segment.allPitchesAboveBass` raised to the (:attr:`~music21.figuredBass.segment.Segment.numParts` - 1) power. The power is 1 less than the number of parts because the bass pitch is constant. >>> allPossibList = list(allPossib) >>> len(segmentA.allPitchesAboveBass) 9 >>> segmentA.numParts 4 >>> len(segmentA.allPitchesAboveBass) ** (segmentA.numParts-1) 729 >>> len(allPossibList) 729 >>> for i in (81, 275, 426): ... [str(p) for p in allPossibList[i]] ['E3', 'C3', 'C3', 'C3'] ['C4', 'C4', 'G4', 'C3'] ['G4', 'G3', 'C4', 'C3'] ro) rrappendrr1rnameWithOctave itertoolsproduct)r@ iterabless rBrzSegment.allSinglePossibilitiespsSF-.$-!2CD %+dm&9&HIIJKKK ),,rDctj_}fd|DS)a Uses :meth:`~music21.figuredBass.segment.Segment.allSinglePossibilities` and returns an iterator through a set of correct possibilities for a Segment, all possibilities which pass all filters in :meth:`~music21.figuredBass.segment.Segment.singlePossibilityRules`. >>> from music21.figuredBass import segment >>> segmentA = segment.Segment() >>> allPossib = segmentA.allSinglePossibilities() >>> allCorrectPossib = segmentA.allCorrectSinglePossibilities() Most of the 729 naive possibilities were filtered out using the default rules set, leaving only 21. >>> allPossibList = list(allPossib) >>> len(allPossibList) 729 >>> allCorrectPossibList = list(allCorrectPossib) >>> len(allCorrectPossibList) 21 >>> for i in (5, 12, 20): ... [str(p) for p in allCorrectPossibList[i]] ['E4', 'G3', 'G3', 'C3'] ['C5', 'G4', 'E4', 'C3'] ['G5', 'G5', 'E5', 'C3'] c>g|]}||S_isCorrectSinglePossibility).0possibAr@s rB z9Segment.allCorrectSinglePossibilities..s-YYYGt/O/OPW/X/XYYYYrD) _compileRulesrrr7r)r@allAs` rBrz%Segment.allCorrectSinglePossibilitiessU8/<  ' ' 5 5/7/7+**,,YYYYtYYYYrDc<|j|jkstd|j|jkstdt||jd|_|jdD]\}}||g|RcS||S)aK Returns an iterator through correct (possibA, possibB) pairs. * If segmentA (self) is a special Segment, meaning that one of the Segment resolution methods in :meth:`~music21.figuredBass.segment.Segment.specialResolutionRules` needs to be applied, then this method returns every correct possibility of segmentA matched up with exactly one resolution possibility. * If segmentA is an ordinary, non-special Segment, then this method returns every combination of correct possibilities of segmentA and correct possibilities of segmentB which passes all filters in :meth:`~music21.figuredBass.segment.Segment.consecutivePossibilityRules`. Two notes on segmentA being a special Segment: 1. By default, resolution possibilities are not filtered using :meth:`~music21.figuredBass.segment.Segment.singlePossibilityRules` rules of segmentB. Filter by setting :attr:`~music21.figuredBass.rules.Rules.applySinglePossibRulesToResolution` to True. 2. By default, (possibA, possibB) pairs are not filtered using :meth:`~music21.figuredBass.segment.Segment.consecutivePossibilityRules` rules of segmentA. Filter by setting :attr:`~music21.figuredBass.rules.Rules.applyConsecutivePossibRulesToResolution` to True. >>> from music21.figuredBass import segment >>> segmentA = segment.Segment(bassNote=note.Note('C3'), notationString='') >>> segmentB = segment.Segment(bassNote=note.Note('D3'), notationString='4,3') Here, an ordinary resolution is being executed, because segmentA is an ordinary Segment. >>> consecutivePairs1 = segmentA.allCorrectConsecutivePossibilities(segmentB) >>> consecutivePairsList1 = list(consecutivePairs1) >>> len(consecutivePairsList1) 31 >>> consecutivePairsList1[29] ((<...G5>, <...G5>, <...E5>, <...C3>), (<...G5>, <...F5>, <...B4>, <...D3>)) Here, a special resolution is being executed, because segmentA below is a special Segment. >>> segmentA = segment.Segment(bassNote=note.Note('D3'), notationString='4,3') >>> segmentB = segment.Segment(bassNote=note.Note('C3'), notationString='') >>> consecutivePairs2 = segmentA.allCorrectConsecutivePossibilities(segmentB) >>> consecutivePairsList2 = list(consecutivePairs2) >>> len(consecutivePairsList2) 6 >>> consecutivePairsList2[5] ((<...G5>, <...F5>, <...B4>, <...D3>), (<...G5>, <...E5>, <...C5>, <...C3>)) z6Two segments with unequal numParts cannot be compared.z6Two segments with unequal maxPitch cannot be compared.rT)rrpr9rrrr6r)r@rresolutionMethodargss rBrz*Segment.allCorrectConsecutivePossibilitiessj !222"#[\\ \("444"#[\\ \.;  ' ' 5 5 / / +)-(KD(Q 5 5 $ t##H4t444 4 4 4++H555rDcN|jdD]\}}}||g|R|ksdSdS)z Takes in a possibility (possibA) from a segmentA (self) and returns True if the possibility is correct given :meth:`~music21.figuredBass.segment.Segment.singlePossibilityRules` from segmentA. TF)r7)r@rmethod isCorrectrs rBrz#Segment._isCorrectSinglePossibilitysP*.)LT)R   %VYF7*T***i77uu8trDcP|jdD]\}}}|||g|R|ksdSdS)z Takes in a (possibA, possibB) pair from a segmentA (self) and segmentB, and returns True if the pair is correct given :meth:`~music21.figuredBass.segment.Segment.consecutivePossibilityRules` from segmentA. TF)r8)r@rpossibBrrrs rB _isCorrectConsecutivePossibilityz(Segment._isCorrectConsecutivePossibilitysT*.)QRV)W   %VYF7G3d333y@@uuAtrDctj_}|}t j||}tfd|S)am An ordinary segment is defined as a segment which needs no special resolution, where the segment does not spell out a special chord, for example, a dominant seventh. Finds iterators through all possibA and possibB by calling :meth:`~music21.figuredBass.segment.Segment.allCorrectSinglePossibilities` on self (segmentA) and segmentB, respectively. Returns an iterator through (possibA, possibB) pairs for which :meth:`~music21.figuredBass.segment.Segment._isCorrectConsecutivePossibility` returns True. >>> from music21.figuredBass import segment cJ|d|dSNrro)rrrpossibABr@s rBz1Segment._resolveOrdinarySegment..&s1t'L'LU]^_U`V^_`Va(M(c(crD)rrrr8rrrfilter)r@rcorrectAcorrectB correctABs` rBrzSegment._resolveOrdinarySegments4A  , ,T\ : :4<4<0557799;;%h99 cccc "" "rDc@t|d}|dD]\}}g}|D])}|tj|*t |g|R}t |} tfd| } jj rtfd| } jj r?t j_ tfd| } | cStd)NrTcFtj|djS)Nro)rr*)r pitchesWithinLimitr9rrs rBrz0Segment._resolveSpecialSegment..2s& 0N  !+1-1-1-rDcJ|d|dSrrrs rBrz0Segment._resolveSpecialSegment..7s+D4Y4Y$QK$QK5Z5)5)rDc<|dS)Nro)rrrs rBrz0Segment._resolveSpecialSegment..>s$H4X4X$QK5Y5)5)rDz!No standard resolution available.)rrrrepeatmaprziprr'applyConsecutivePossibRulesToResolution"applySinglePossibRulesToResolutionrr7rp) r@rspecialResolutionMethodsresolutionMethodExecutorrrrarg resolutionsrs `` rBrzSegment._resolveSpecialSegment*s~#01I1#M#M (@(F   $ tI 8 8  !1#!6!67777.0R0R0T0TaW`aaaKD>>@@+NNI - - - -I|C "$)$)$)$) |> :G33H4DEE;G;G7"$)$)$)$)    BCCCrD)r!NNNr"r#N) rr$r%r&r'r(rr)r*r+N)F)__name__ __module__ __qualname__ _DOC_ORDERr __annotations__rCrrrrrrrrrrrrrrrDrBrr#s222J4%a ] @a%!!I,,0,0@D-1-1#P;P;P;P;P;j7!7!7!7!rP&P&P&P&dMMMM^a:a:a:FE:E:E:E:NS:S:S:j%-%-%-NZZZB?6?6?6H      """,DDDDDrDrceZdZdZdZdS)OverlaidSegmentzF Class to allow Segments to be overlaid with non-chord notes. c|jg|jdz z}|tj|jjjg|jjD]%\}}tj|jg||dz <&tj |S)Nro) rrrrr1rrr_partPitchLimitsrr)r@r partNumber partPitchs rBrz&OverlaidSegment.allSinglePossibilitiesKs-.$-!2CD %+dm&9&HIIJKKK'+|'D P P #Z).Y5M)N)N(OIj1n % % ),,rDN)rrr__doc__rrrDrBrrFs------rDrCEGr!C8 bassPitchr+r*cttrtjttrtjjt dt j|tjdz}td|}t j fd|}t j fd|}t|}| |S)a Given a list of pitchNames, a bassPitch, and a maxPitch, returns a sorted list of pitches between the two limits (inclusive) which correspond to items in pitchNames. >>> from music21.figuredBass import segment >>> pitches = segment.getPitches() >>> print(', '.join([p.nameWithOctave for p in pitches])) C3, E3, G3, C4, E4, G4, C5, E5, G5, C6, E6, G6, C7, E7, G7, C8 >>> pitches = segment.getPitches(['G', 'B', 'D', 'F'], bassPitch=pitch.Pitch('B2')) >>> print(', '.join([p.nameWithOctave for p in pitches])) B2, D3, F3, G3, B3, D4, F4, G4, B4, D5, F5, G5, B5, D6, F6, G6, B6, D7, F7, G7, B7 >>> pitches = segment.getPitches(['F##', 'A#', 'C#'], bassPitch=pitch.Pitch('A#3')) >>> print(', '.join([p.nameWithOctave for p in pitches])) A#3, C#4, F##4, A#4, C#5, F##5, A#5, C#6, F##6, A#6, C#7, F##7, A#7 The maxPitch must have an octave: >>> segment.getPitches(maxPitch=pitch.Pitch('E')) Traceback (most recent call last): ValueError: maxPitch must be given an octave Nz maxPitch must be given an octaverocbtj|dt|dzS)Nrro)rr1r/)xs rBrzgetPitches..ws#%+adS1YY&677rDc|kSrr) samplePitchrs rBrzgetPitches..xs i+6MrDc|kSrr)rr*s rBrzgetPitches..ys kH6LrD) r.r/rr1octave ValueErrorrrranger filterfalselistsort) pitchNamesrr*iter1iter2iter3iter4 allPitchess `` rBr;r;Us4)S!!+K ** (C  );x((;<<<  j%!0C*D*D E EE 77 ? ?E  !"M"M"M"Mu U UE  !"L"L"L"Le T TEeJOO rDc|}|}|d}|d}|d}|||||g}|S)Nrrrrrx getChordStep) seventhChordrrxthirdfifthseventhseventhChordInfos rBrqrqst     D     D  % %a ( (E  % %a ( (E''**GdE5': rDc|}|}|d}|d}||||g}|S)Nrrr )threePartChordrrxr rthreePartChordInfos rBraras_    D    D  ' ' * *E  ' ' * *EeU3 rDr"ctjt}tt |D]}g}t |||kr||d}|dkr3||dd\}}}|||||fd|dkr0||dd\}}||||f|S)Nr"rrrn) collections defaultdictrrlenr) rulesList maxLength ruleChecking ruleIndexrshouldRunMethodrrs rBrrs*400L3y>>** A A  y# $ $ 1 1Y'+D >>3 fd}dd dz zz}|dkrtd |d n|d krtd |d tt|D]}d }g}t|||kr||d}|sd}nTd}tt|D]5} |t || z }| t|dz ks|dz }6|dkrF||dd \} } } || } t | d| t | d|}n:|d kr4||dd\} } || } t | d| |}t|d S)a Method which can print to the console rules inputted into :meth:`~music21.figuredBass.segment.Segment.singlePossibilityRules`, :meth:`~music21.figuredBass.segment.Segment.consecutivePossibilityRules`, and :meth:`~music21.figuredBass.segment.Segment.specialResolutionRules`. For the first two methods, maxLength is 4. For the third method, maxLength is 3. OMIT_FROM_DOCS maxLength is the maximum length of a rule, a rule which includes arguments, because arguments are optional. rornc||jd}t|kr|dt|z zz }|S)Nr )rr)m methodNameMAX_SIZEs rB padMethodzprintRules..padMethodsDZ( + z??X % % #C OO!;< >**   y# $ $ 1 1Y'+D 'JJJ"3t99-- ' ' c$y/222  CIIM11$&J >>3rrrrr;rqrarr0Music21ExceptionrpTestCaser5rmainTestrrDrBr>s#""""""  ++++++------******%%%%%% TI ` D` D` D` D` D` D` D` DF - - - - -g - - -*,0+/'''''T     2222j     |4        8     zNNNGTrD