rh%SSKJr SSKrSSKrSSKrSSKrSSKJr SSKJr SSKJ r SSKJ r SSKJ r SSKJ r SS K Jr SS K Jr SS K Jr SS K Jr S rSS0rS\S'"SS5r"SS\5rSS SjjrSrSrS!SjrS!Sjr"SS\ R85r"SS\R<5r\ S:XaSSKr\RB"\5 gg)") annotationsN)chord) environment) exceptions21)note)pitch)scale) possibility) realizerScale) resolution)ruleszfiguredBass.segmentr z0dict[str, realizerScale.FiguredBassScale | None]_defaultRealizerScalec\rSrSr%/SQrSSSSSSS .rS \S 'SSS jjrSSjrSSjr SSjr Sr SSjr Sr SrSrSrSrSrSrSrSrg ) 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_ATTRNc\[U[5(a[R"U5n[U[5(a[R "U5nUc/[ Sc[R"5[ S'[ SnUceUc[R"5Ul O[R"U5Ul SUlSUlSUlXlXPlX`lUc UbXplO+UR+UR"RU5Ul[-UR(UR"RUR&5Ul[0R2"UR.UR4S9Ul:"[<5Ulg)a_ 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 Rulesr copydeepcopy_specialResolutionRuleChecking_singlePossibilityRuleChecking#_consecutivePossibilityRuleCheckingrr _maxPitchr getPitchNames getPitchesrrChordr#rr Environment_MOD _environRules)selfrnotationStringfbScaler rmaxPitch listOfPitchess U/home/james-whalen/.local/lib/python3.13/site-packages/music21/figuredBass/segment.py__init__Segment.__init__CsR\ h $ $yy*H h $ ${{8,H ?$W-51>1O1O1Q%g.+G4G""" ? ;;=DL==1DL.2+.2+370  !  !m&?%2 "&-%:%:4==;N;NP^%_D "#-d.D.D.2mm.A.A.2nn$> "KK(@(@6>6L6LN(44T:cUc[R"5nUR[RSUR /4S[R SUR/4UR[RS4/nU$)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 FT) r r)forbidIncompletePossibilitiesr isIncompleterupperPartsWithinLimitupperPartsMaxSemitoneSeparationforbidVoiceCrossing voiceCrossing)r6r singlePossibRuless r;rSegment.singlePossibilityRulessL ?kkmG 2 2))(() +2299: < ( (**   ! r>cUc[R"5nURR5nS[R SUR /4UR[RS4UR[RS4S[RSUR/4UR[RS4UR[R S4UR"[R$S4UR&[R(S4UR*=(a U[R,S[/UR5UR0/4/ nU$)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 TF)r r)risItalianAugmentedSixthr partsSame _partsToCheck_upperPartsRemainSameupperPartsSameforbidVoiceOverlap voiceOverlappartMovementsWithinLimitspartMovementLimitsforbidParallelFifthsparallelFifthsforbidParallelOctavesparallelOctavesforbidHiddenFifths hiddenFifthforbidHiddenOctaves hiddenOctaveresolveAugmentedSixthProperlycouldBeItalianA6Resolution _unpackTriad&restrictDoublingsInItalianA6Resolution)r6r rIconsecutivePossibRuless r;r#Segment.consecutivePossibilityRuless0x ?kkmG"&"3"3"K"K"M;(($1F1F0G H  * *K,F,F M  ' ')A)A5 I ;88$A[A[@\ ]  ) );+E+Eu M  * *K,G,G O  ' ')@)@% H  ( (+*B*BE J  2 2 N7N66d//0'2`2`a c " &%r>cUc[R"5nURR5nURR 5nURR 5nUR =(a UUR4UR=(a UURUR/4UR=(a UUR4/nU$)a 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 r)risDominantSeventhisDiminishedSeventhisAugmentedSixthresolveDominantSeventhProperlyr resolveDiminishedSeventhProperlyrdoubledRootInDim7rZr)r6r rarbrcspecialResRuless r;rSegment.specialResolutionRules$s| ?kkmG --??A"//CCE,,==? 3 3 I8I  / / 1  5 5 M:M44**+ - 2 2 G7G11 3  r>czURnUR5(d [S5e[U5n[R "5R U5nUR5nUR5nURS5nURS5nURS5n URn UR5S:Hn U R5n U =(a U S:Hn UR5S:XacU R5RUR:Xa;U R5(dU R5(aSURlU R5RUR:H=(a U R5["R$X/4U R5RUR:H=(a U R5["R&X/4U R5RUR:H=(a U R5=(a U S:H["R(U/4U R5RU R:H=(a U R5=(a U S:H["R*U/4U R5RUR:H=(a U R5=(a U S:H["R,U/4U R5RUR:H=(a U R5=(a U S:H["R.U/4/nUR1X5$![a/ UR2R5S5 UR7U5s$f=f) aX 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>)) z>> 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.rjrmrTFz]Diminished seventh resolution: No proper resolution available. Executing ordinary resolution.)rrbrnror HarmonicMinorScalederiveByDegreervrsrtrurwrxr diminishedSeventhToMajorTonicrydiminishedSeventhToMinorTonic#diminishedSeventhToMajorSubdominant#diminishedSeventhToMinorSubdominantrr5rr) r6r doubledRootdimChord dimChordInfodimScalerrrdiminishedResolutionMethodss r;r'Segment.resolveDiminishedSeventhSegments:$$++--"RT T*84 ++-<> ]]_ ! ![%5%5 5 Q(:O:O:Q>>  ' # :..xU U :    # #3 4//9 9  :sH))6I"!I"c2URnUR5(d [S5eUR5(aUR U5$UR 5(aSnO\UR 5(aSnODUR5(aSnO,URRS5 UR U5$[R"UR5S5n[R"U5nURn[U5nUR!5S:H=(a> UR#5R$UR$:H=(a UR'5[R(X7/4UR!5S:H=(a> UR#5R$UR$:H=(a UR+5[R,X7/4UR/S5R$UR5R$:H=(a UR'5[R0X7/4/nUR3X5$![a/ URRS5 UR U5s$f=f) 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.rmrlz^Augmented sixth resolution: Augmented sixth type not supported. Executing ordinary resolution.M3zZAugmented sixth resolution: No proper resolution available. Executing ordinary resolution.)rrcrnrIrisFrenchAugmentedSixthisGermanAugmentedSixthisSwissAugmentedSixthr5rr _transposebassr rprorurvrwrxaugmentedSixthToMajorTonicryaugmentedSixthToMinorTonicrtaugmentedSixthToDominantr) r6r augSixthChord augSixthTyper majorScaleraugSixthChordInfoaugmentedSixthResolutionMethodss r;r$Segment.resolveAugmentedSixthSegmentsEL)) --//"#`a a  0 0 2 2//9 9  1 1 3 3L  1 1 3 3L  0 0 2 2L    # #W X//9 9%%m&8&8&:DA%%e, ((/ >  "a',MMO((EJJ6,))+  2 2\4U W  "a',MMO((EJJ6,))+551  3 ((+00HMMO4H4HH,))+331 3+ '  :..xY Y :    # #3 4//9 9  :s I6JJcUR/URS- -nUR[R"UR RR 5/5 [R"U6$)a8 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'] rm) rrappendrr'rnameWithOctave itertoolsproduct)r6 iterabless r;rSegment.allSinglePossibilitiesus\J--.$--!2CD %++dmm&9&9&H&HIJK  ),,r>c[URUR55UlUR 5nUVs/sHo R U5(dMUPM sn$s snf)aZ 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'] ) _compileRulesrr r-r_isCorrectSinglePossibility)r6allApossibAs r;r%Segment.allCorrectSinglePossibilitiessU>/<  ' ' 5/7+**,'+YtG/O/OPW/XtYYYs A$A$cNURUR:Xd [S5eURUR:Xd [S5e[UR UR 5S5UlUR SHup#U"U/UQ76s $ URU5$)a 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)rrnr/rrr r,r)r6rresolutionMethodargss r;r*Segment.allCorrectConsecutivePossibilitiessj !2!22"#[\ \("4"44"#[\ \.;  ' ' 5 / +)-(K(KD(Q $ #H4t4 4)R++H55r>cTURSHup#nU"U/UQ76U:XaM g g)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)r-)r6rmethod isCorrectrs r;r#Segment._isCorrectSinglePossibilitys9*.)L)LT)R %V7*T*i7*Sr>cTURSHup4nU"X/UQ76U:XaM g g)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)r.)r6rpossibBrrrs r; _isCorrectConsecutivePossibility(Segment._isCorrectConsecutivePossibilitys:*.)Q)QRV)W %V73d3y@*Xr>c^[TRTR55TlTR 5nUR 5n[ R "X#5n[U4SjU5$)a& 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 c0>TRUSUSS9$Nrrm)rrrpossibABr6s r;1Segment._resolveOrdinarySegment..1s)t'L'LU]^_U`V^_`Va(M(cr>)rrr r.rrrfilter)r6rcorrectAcorrectB correctABs` r;rSegment._resolveOrdinarySegmentsg4A  , ,T\\ :4<055799;%%h9 c " "r>c<^^[US5nUSHupE/nUH(nUR[R"U55 M* [ UTR 5/UQ76n[ TR 5U5n [U4SjU 5n TRR(a[U4SjU 5n TRR(a9[TRTR55Tl [U4SjU 5n U s $ [S5e)NrTcH>[R"USTRS9$)Nrm)rr9)r pitchesWithinLimitr/rrs r;r0Segment._resolveSpecialSegment..=s 0N0N  !++1-r>c0>TRUSUSS9$rrrs r;rrBs$D4Y4Y$QK$QK5Z5)r>c(>TRUSS9$)Nrm)r)rrs r;rrIsH4X4X$QK5Y5)r>z!No standard resolution available.)rrrrepeatmaprziprr 'applyConsecutivePossibRulesToResolution"applySinglePossibRulesToResolutionrr-rn) r6rspecialResolutionMethodsresolutionMethodExecutorrrrarg resolutionsrs `` r;rSegment._resolveSpecialSegment5s#01I1#M (@(F $ I  !1!1#!67.0R0R0TaW`aKD>>@+NI -I||CC"$) ||>>:G33H4D4DE;G7"$)  +)G.BCCr>) r.r5r/r-r,rrr rrr)C3NNNrjB5N) rzstr | note.Noter7z str | Noner8z%realizerScale.FiguredBassScale | Noner zrules.Rules | Noner9str | pitch.PitchN)F)__name__ __module__ __qualname____firstlineno__ _DOC_ORDERr!__annotations__r<rrrrrrrrrrrrr__static_attributes__r>r;rr$s2J4%a ] @a%!I~,,0,0@D-1-1#Q;(Q;!)Q;>Q;+ Q; + Q;l7!rP&dOba:FE:NT:l'-R"ZH?6H  ".Dr>rc\rSrSrSrSrSrg)OverlaidSegmentiQz> Class to allow Segments to be overlaid with non-chord notes. ctUR/URS- -nUR[R"UR RR 5/5 URRH+up#[R"UR 5/XS- 'M- [R"U6$)Nrm) rrrrr'rrr _partPitchLimitsrr)r6r partNumber partPitchs r;r&OverlaidSegment.allSinglePossibilitiesVs--.$--!2CD %++dmm&9&9&H&HIJK'+||'D'D #Z).Y5M5M)N(OI1n %(E  ),,r>rN)rrrr__doc__rrrr>r;rrQs -r>rc^^[T[5(a[R"T5m[T[5(a[R"T5mTRc [ S5e[ R"U[TRS-55n[SU5n[ R"U4SjU5n[ R"U4SjU5n[U5nUR5 U$)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 z maxPitch must be given an octavermcR[R"US[US5-5$)Nrrm)rr'r%)xs r;rgetPitches..s%++adS1Y&67r>c>TU:$rr) samplePitch bassPitchs r;rrs i+6Mr>c>UT:$rr)rr9s r;rrs kH6Lr>) r$r%rr'octave ValueErrorrrranger filterfalselistsort) pitchNamesrr9iter1iter2iter3iter4 allPitchess `` r;r1r1`s4)S!!KK * (C  ;;x(;<<   j%!0C*D EE 7 ?E  ! !"Mu UE  ! !"Le TEeJOO r>cUR5nUR5nURS5nURS5nURS5nXX4U/nU$)Nrrrrrv getChordStep) seventhChordrrvthirdfifthseventhseventhChordInfos r;rorosa    D    D  % %a (E  % %a (E''*GE': r>cUR5nUR5nURS5nURS5nXX4/nU$)Nrrr)threePartChordrrvrrthreePartChordInfos r;r\r\sO    D    D  ' ' *E  ' ' *Ee3 r>c<[R"[5n[[ U55Hin/n[ X5U:XaXSnUS:Xa!XSSupVnX%R XgU45 MDUS:XdMLXSSupVX%R Xd45 Mk U$)Nrjrrrl) collections defaultdictr rlenr) rulesList maxLength ruleChecking ruleIndexrshouldRunMethodrrs r;rrs**40L3y>*  y# $ 1'+D >3<3G!3L 0_i  ) 0 0&T1J K !^(1(c^ Sm UH<n[USR5T :dM![USR5S-m M> U 4SjnSST S- --nUS:Xa[S US 35 OUS :Xa[S US 35 [[U55HnS n/n[X5U:XaXSnU(dSnOFSn[[U55H,n U[ Xy5- nU [U5S- :XaM'US- nM. US:Xa1XSS upn U"U 5n [ U 5SU [ U 5SU3nO)US :Xa#XSSupU"U 5n [ U 5SU U3n[U5 M g )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. rmrlcl>URSTn[U5T:aUST[U5- -- nU$)Nr )rr )m methodNameMAX_SIZEs r; padMethodprintRules..padMethods=ZZ(+ z?X % #C O!;< zMethod:r)rrjz Will run: z(Keep solutions which return: Arguments:rz Arguments:NrNonez, r1130)r rprintrr%)r!r"ruler- methodStrr$ ruleToPrintr argsString itemIndexr%rrr,s @r; printRulesr9sH tAw H ,47++,q0H C8a<00IA~ I;&NOP a I;j123y>*   y# $ 1'+DJJ"3t9- c$/22  CIM1$&J. >3<3G!3L 0_iv&F 1"5fXc)nR=PQ[P\]K !^(1(c\rSrSrSrg)rnirNrrrrrrr>r;rnrnr>rnc\rSrSrSrg)TestirNr;rr>r;r>r>r<r>r>__main__))CEGrC8)rrr9r)rj)" __future__rrr*runittestmusic21rrrrrr music21.figuredBassr r r r r4rrrrr1ror\rr9Music21ExceptionrnTestCaser>rmainTestrr>r;rKs#  +-*% TIE j Dj DZ -g -*,0+/')'('T  2j |44  8    z Tr>