rhtSrSSKJr SSKJr SSKJr SSKrSSKrSSK r SSK J r SSK J r SSK Jr SS K Jr SS K Jr SS K Jr SS K Jr \ R&"S 5r"SS\R*5r"SS\R*5r\\\-\\S-\S-\\S-4rSrSr"SS\R>5r "SS\RB5r""SS\RB\ RF5r$"SS\R>5r%"SS5r&"SS\&5r'\&\$\"/r(\)S :XaSSK r \ RT"5 gg)!a An IntervalNetwork defines a scale or harmonic unit as a (weighted) digraph, or directed graph, where pitches are nodes and intervals are edges. Nodes, however, are not stored; instead, an ordered list of edges (Intervals) is provided as an archetype of adjacent nodes. IntervalNetworks are unlike conventional graphs in that each graph must define a low and high terminus. These points are used to create a cyclic graph and are treated as point of cyclical overlap. IntervalNetwork permits the definition of conventional octave repeating scales or harmonies (abstract chords), non-octave repeating scales and chords, and ordered interval sequences that might move in multiple directions. A scale or harmony may be composed of one or more IntervalNetwork objects. Both nodes and edges can be weighted to suggest tonics, dominants, finals, or other attributes of the network. Changed in v8: nodeId and nodeName standardized. TERMINUS and DIRECTION are now Enums. ) annotations) OrderedDict)SequenceN)common) environment) exceptions21)interval)note)pitch)prebasezscale.intervalNetworkc,\rSrSrSrSrSrSrSrSr g) Terminus5zI One of the two Termini of a scale, either Terminus.LOW or Terminus.HIGH terminusLow terminusHighc SUR-$Nz Terminus.nameselfs W/home/james-whalen/.local/lib/python3.13/site-packages/music21/scale/intervalNetwork.py__repr__Terminus.__repr__=TYY&&c SUR-$rrrs r__str__Terminus.__str__@rrN) __name__ __module__ __qualname____firstlineno____doc__LOWHIGHrr__static_attributes__r rrrr5s C D''rrc0\rSrSrSrSrSrSrSrSr Sr g ) DirectionCzx An enumerated Direction for a scale, either Direction.ASCENDING, Direction.DESCENDING, or Direction.BI (bidirectional) bi ascending descendingc SUR-$Nz Direction.rrs rrDirection.__repr__Ldii''rc SUR-$r0rrs rrDirection.__str__Or2rr N) r!r"r#r$r%BI ASCENDING DESCENDINGrrr(r rrr*r*Cs" BIJ((rr*c4X:ag[X- 5S:agg)z( check if a > b or abs(a - b) < epsilon Th㈵>Fabsabs r_gter?W  u QUg  rc4X:ag[X- 5S:agg)z( check if a < b or abs(a - b) < epsilon Tr9Fr:r<s r_lterBbr@rc\rSrSrSrg) EdgeExceptionmr Nr!r"r#r$r(r rrrDrDmrrDc\rSrSrSrS\R 4S SjjrSrSr S SSjjr Sr S SS jjr \ SS j5rS rg)Edgeqa Abstraction of an Interval as an Edge. Edges store an Interval object as well as a pathway direction specification. The pathway is the route through the network from terminus to terminus, and can either by ascending or descending. For directed Edges, the direction of the Interval may be used to suggest non-pitch ascending movements (even if the pathway direction is ascending). Weight values, as well as other attributes, can be stored. >>> i = interval.Interval('M3') >>> e = scale.intervalNetwork.Edge(i) >>> e.interval is i True >>> e.direction Direction.BI Return the stored Interval object >>> i = interval.Interval('M3') >>> e1 = scale.intervalNetwork.Edge(i, id=0) >>> n1 = scale.intervalNetwork.Node(id=0, degree=0) >>> n2 = scale.intervalNetwork.Node(id=1, degree=1) >>> e1.addDirectedConnection(n1, n2, scale.Direction.ASCENDING) >>> e1.interval Return the direction of the Edge. >>> i = interval.Interval('M3') >>> e1 = scale.intervalNetwork.Edge(i, id=0) >>> n1 = scale.intervalNetwork.Node(id=0, degree=0) >>> n2 = scale.intervalNetwork.Node(id=1, degree=1) >>> e1.addDirectedConnection(n1, n2, scale.Direction.ASCENDING) >>> e1.direction Direction.ASCENDING Nc[U[5(a[R"U5nOUnX@lX0lSUlX l/Ulg)N?) isinstancestrr Interval directionweightid _connections)r intervalDatarRrPis r__init__ Edge.__init__sH lC ( (!!,/AA+, $- FHrcl[XR5=(a URUR:H$)a >>> i1 = interval.Interval('M3') >>> i2 = interval.Interval('M3') >>> i3 = interval.Interval('m3') >>> e1 = scale.intervalNetwork.Edge(i1) >>> e2 = scale.intervalNetwork.Edge(i2) >>> e3 = scale.intervalNetwork.Edge(i3) >>> e1 == e2 True >>> e1 == e3 False )rM __class____dict__rothers r__eq__ Edge.__eq__s*5..14MMU^^3 5rchURSURRSUR<3$)N )rPr rrSrs r _reprInternalEdge._reprInternals0..!4==#5#5"6a8I8I7LMMrcN[U[[45(aUnO URn[U[[45(aUnO URnURR XE45 U[ R[ R4;a [S5eX0l g)ao Provide two Node objects that are connected by this Edge, in the direction from the first to the second. When calling directly, a direction, either ascending or descending, should be set here; this will override whatever the interval is. If None, this will not be set. >>> i = interval.Interval('M3') >>> e1 = scale.intervalNetwork.Edge(i, id=0) >>> n1 = scale.intervalNetwork.Node(id=0, degree=0) >>> n2 = scale.intervalNetwork.Node(id=1, degree=1) >>> e1.addDirectedConnection(n1, n2, scale.Direction.ASCENDING) >>> e1.connections [(0, 1)] >>> e1 zmust request a directionN) rMrintrRrSappendr*r6r7rDrP)rnode1node2rPn1Idn2Ids raddDirectedConnectionEdge.addDirectedConnections8 eh_ - -D88D eh_ - -D88D   $. Y00)2F2FG G :; ;"rcURX[R5 URX![R5 [RUlg)a Provide two Edge objects that pass through this Node, in the direction from the first to the second. >>> i = interval.Interval('M3') >>> e1 = scale.intervalNetwork.Edge(i, id=0) >>> n1 = scale.intervalNetwork.Node(id=scale.Terminus.LOW, degree=0) >>> n2 = scale.intervalNetwork.Node(id=1, degree=1) >>> e1.addBiDirectedConnections(n1, n2) >>> e1.connections [(Terminus.LOW, 1), (1, Terminus.LOW)] >>> e1 N)rjr*r6r7r5rP)rrfrgs raddBiDirectedConnectionsEdge.addBiDirectedConnectionss;$ ""51D1DE ""51E1EF"rc Uc URnURU:Xa UR$U[R:Xa9UR[R[R 4;a [ S5eU[R[R 4;afUR[R:XaHU[R:XaURS/$U[R :XaURS/$/$)a Callable as a property (.connections) or as a method (.getConnections(direction)): Return a list of connections between Nodes, represented as pairs of Node ids. If a direction is specified, and if the Edge is directional, only the desired directed values will be returned. >>> i = interval.Interval('M3') >>> e1 = scale.intervalNetwork.Edge(i, id=0) >>> n1 = scale.intervalNetwork.Node(id=scale.Terminus.LOW, degree=1) >>> n2 = scale.intervalNetwork.Node(id=1, degree=2) >>> e1.addBiDirectedConnections(n1, n2) >>> e1.connections [(Terminus.LOW, 1), (1, Terminus.LOW)] >>> e1.getConnections(scale.Direction.ASCENDING) [(Terminus.LOW, 1)] >>> e1.getConnections(scale.Direction.DESCENDING) [(1, Terminus.LOW)] z3cannot request a bi direction from a mono directionr)rPrSr*r5r6r7rD)rrPs rgetConnectionsEdge.getConnectionss2  I >>Y &$$ $  %NNy':':Ia4 Abstraction of an unrealized Pitch Node. The Node `id` is used to store connections in Edges and has no real meaning. Terminal Nodes have special ids: Terminus.LOW, Terminus.HIGH The Node `degree` is translated to scale degrees in various applications, and is used to request a pitch from the network. The `weight` attribute is used to probabilistically select between multiple nodes when multiple nodes satisfy either a branching option in a pathway or a request for a degree. TODO: replace w/ NamedTuple; eliminate id, and have a terminus: low, high, None rRdegreerQc(XlX lX0lgrtr~)rrRrrQs rrV Node.__init__Ss!#" # rc^URURUR4n[U5$rt)rRrrQhash)r hashTuples r__hash__ Node.__hash__^s$WWdkk4;;7 Irc0[U5[U5:H$)a Nodes are equal if everything in the object.__slots__ is equal. >>> n1 = scale.intervalNetwork.Node(id=3, degree=1) >>> n2 = scale.intervalNetwork.Node(id=3, degree=1) >>> n3 = scale.intervalNetwork.Node(id=2, degree=1) >>> n1 == n2 True >>> n1 == n3 False >>> n2.weight = 2.0 >>> n1 == n2 False >>> n4 = scale.intervalNetwork.Node(id=scale.Terminus.LOW, degree=1) >>> n5 = scale.intervalNetwork.Node(id=scale.Terminus.LOW, degree=1) >>> n4 == n5 True )rr[s rr] Node.__eq__bs(DzT%[((rc"SUR<3$)Nzid=rRrs rraNode._reprInternalxsTWWK  r)rrRrQN)rL)rRzTerminus | intrrdrQfloat) r!r"r#r$r% __slots__rVrr]rar(r rrr}r}>s" +I $),!rr}c\rSrSrSrg)IntervalNetworkExceptioni}r NrFr rrrr}rGrrc\rSrSr%SrS?S@SjjrSrSrS@SjrS r S r S r S r \ S 5r\ S5r\ S5r\ SASj5r\ S5rSBSCSjjrSrSrSDSjrSSS.SESjjrSrSr\R6SS.SFSjjr\R:SSSS.SGSjjrSS .SHS!jjrSISSS".SJS#jjjr SISSSSS$.SKS%jjjr!SSS\R:SS4SLS&jjr"SSS\R:SS4SMS'jjr#SSS\R:SS4SNS(jjr$SOSPS)jjr%SOSPS*jjr&SS+SS\R:S4SQS,jjr'S-r(S.r)S/\R:SS0.SRS1jjr*\R:S4SSS2jjr+S/\R:S4STS3jjr,\R:SSSS4SUS4jjr-\.SVS5j5r/SWSXS7jjr0S6SS\R:S4SYS8jjr1S9r2S:\3S;'SZS<jr4S[S=jr5S>r6g)\IntervalNetworkia0 A graph of undefined Pitch nodes connected by a defined, ordered list of :class:`~music21.interval.Interval` objects as edges. An `octaveDuplicating` boolean, if defined, can be used to optimize pitch realization routines. The `deterministic` boolean, if defined, can be used to declare that there is no probabilistic or multi-pathway segments of this network. The `pitchSimplification` method specifies how to simplify the pitches if they spiral out into double and triple sharps, etc. The default is 'maxAccidental' which specifies that each note can have at most one accidental; double-flats and sharps are not allowed. The other choices are 'simplifyEnharmonic' (which also converts C-, F-, B#, and E# to B, E, C, and F respectively, see :meth:`~music21.pitch.Pitch.simplifyEnharmonic`), 'mostCommon' (which adds to simplifyEnharmonic the requirement that the most common accidental forms be used, so A# becomes B-, G- becomes F#, etc. the only ambiguity allowed is that both G# and A- are acceptable), and None (or 'none') which does not do any simplification. FTcSUlSUl[5Ul[5UlU(aUR U5 X lX0lX@l[5Ul [5Ul g)Nr) edgeIdCount nodeIdCountredgesnodesfillBiDirectedEdgesoctaveDuplicating deterministicpitchSimplification_ascendingCache_descendingCache)redgeListrrrs rrVIntervalNetwork.__init__sq7Bm 7Bm   $ $X ."3*$7 M  M rcSUlSUl[5Ul[5Ul[5Ul[5Ulg)z' Remove and reset all Nodes and Edges. rN)rrrrrrrrs rclearIntervalNetwork.clears: ]  ] *} + rc[XR5(dgSHn[X5[X5:wdM g g)a >>> edgeList1 = ['M2', 'M2', 'm2', 'M2', 'M2', 'M2', 'm2'] >>> edgeList2 = ['M2', 'M2', 'm2', 'M2', 'A3', 'm2'] >>> net1 = scale.intervalNetwork.IntervalNetwork() >>> net1.fillBiDirectedEdges(edgeList1) >>> net2 = scale.intervalNetwork.IntervalNetwork() >>> net2.fillBiDirectedEdges(edgeList1) >>> net3 = scale.intervalNetwork.IntervalNetwork() >>> net3.fillBiDirectedEdges(edgeList2) >>> net1 == net2 True >>> net1 == net3 False F)rrrrrrrT)rMrYgetattr)rr\attrs rr]IntervalNetwork.__eq__s>,%00RDt"ge&::RrcNUR5 Sn[[RUS9nUS- nX0RUR 'Un[ U5HupVU[U5S- :a1[URUS9nU=RS- slUS- nUnO[[RUS9n U nXRUR '[X`RS9n XRU R 'U=RS- sl U RXH5 UnM g)a Given an ordered list of bi-directed edges given as :class:`~music21.interval.Interval` specifications, create and define appropriate Nodes. This assumes that all edges are bi-directed and all edges are in order. >>> edgeList = ['M2', 'M2', 'm2', 'M2', 'M2', 'M2', 'm2'] >>> net = scale.intervalNetwork.IntervalNetwork() >>> net.nodes OrderedDict() >>> net.edges OrderedDict() >>> net.fillBiDirectedEdges(edgeList) >>> net.nodes OrderedDict([(Terminus.LOW, ), (0, ), (1, ), ... (5, ), (Terminus.HIGH, )]) >>> net.edges OrderedDict([(0, ), (1, ), (2, ), ... (5, ), (6, )]) >>> [str(p) for p in net.realizePitch('g4')] ['G4', 'A4', 'B4', 'C5', 'D5', 'E5', 'F#5', 'G5'] >>> net.degreeMin, net.degreeMax (1, 8) Using another fill method creates a new network >>> net.fillBiDirectedEdges(['M3', 'M3', 'M3']) >>> [str(p) for p in net.realizePitch('g4')] ['G4', 'B4', 'D#5', 'G5'] >>> net.degreeMin, net.degreeMax (1, 4) >>> net.fillBiDirectedEdges([interval.Interval('M3'), ... interval.Interval('M3'), ... interval.Interval('M3')]) >>> [str(p) for p in net.realizePitch('c2')] ['C2', 'E2', 'G#2', 'B#2'] rprRrrN)rr}rr&rrR enumeratelenrr'rIrrrm) rr degreeCountnLow nPreviousrUeNamen nFollowingnHighes rr#IntervalNetwork.fillBiDirectedEdgessh  x||K8q " 477 !(+HA3x=1$$D,,[A  A% q   kB" )3JJz}} %U//0A JJqtt     !  & &y ="I/,rcUR5 [U5[U5:wa [S5eSn[[R US9nUS- nX@R UR'Un[U5HupgU[U5S- :a1[URUS9nU=RS- sl US- nUn O[[RUS9n U n XR U R'[XpRS9n XRU R'U=RS- sl U RXY[R S9 U nM SnUR [R nUS- nUn[U5HupgU[U5S- :aI[URUS9nU=RS- sl US- nUn XR U R'OUR [Rn U n [XpRS9n XRU R'U=RS- sl U RX[R"S9 U nM g)a Given two lists of edges, one for ascending :class:`~music21.interval.Interval` objects and another for descending, construct appropriate Nodes and Edges. Note that the descending :class:`~music21.interval.Interval` objects should be given in ascending form. z*cannot manage unequal sized directed edgesrprrrPN)rrrr}rr&rrRrrr'rIrrrjr*r6r7) rascendingEdgeListdescendingEdgeListrrrrUrrrrrs rfillDirectedEdges!IntervalNetwork.fillDirectedEdgesNs7   !S);%< <*+WX X x||K8q " 477 !"34HA3()A--D,,[A  A% q   kB" )3JJz}} %U//0A JJqtt     !  # #I.7.A.A $ C#I/56 zz(,,'q  !"45HA3)*Q..D,,[A  A% q  ,6 :==) 8==1" U//0A JJqtt     !   # #JYEYEY # Z"I-6rcUR5 UH;n[USUSS9nSU;a USUlX@RUR'M= SnUHn[ USUS9nUSHsupn U [ R:Xa.URURUURU 5 MHURURUURU U S 9 Mu XpRUR'US - nM g ) aR Fill any arbitrary network given node and edge definitions. Nodes must be defined by a dictionary of id and degree values. There must be a terminusLow and terminusHigh id as string:: nodes = ({'id': Terminus.LOW, 'degree': 1}, {'id': 0, 'degree': 2}, {'id': Terminus.HIGH, 'degree': 3}, ) Edges must be defined by a dictionary of :class:`~music21.interval.Interval` strings and connections. Values for `id` will be automatically assigned. Each connection must define direction and pairs of valid node ids:: edges = ({'interval': 'm2', 'connections': ([Terminus.LOW, 0, Direction.BI],) }, {'interval': 'M3', 'connections': ([0, Terminus.HIGH, Direction.BI],) }, ) >>> nodes = ({'id': scale.Terminus.LOW, 'degree': 1}, ... {'id': 0, 'degree': 2}, ... {'id': scale.Terminus.HIGH, 'degree': 3}) >>> edges = ({'interval': 'm2', ... 'connections': ([scale.Terminus.LOW, 0, scale.Direction.BI],)}, ... {'interval': 'M3', ... 'connections': ([0, scale.Terminus.HIGH, scale.Direction.BI],)},) >>> net = scale.intervalNetwork.IntervalNetwork() >>> net.fillArbitrary(nodes, edges) >>> net.realizePitch('c4', 1) [, , ] rRrrrQrr rrurrpN) rr}rQrrRrIr*r5rmrjr) rrrnDictreIdeDictrnId1nId2rPs r fillArbitraryIntervalNetwork.fillArbitrarysN Ed E(O !JJqtt  1HCrc [RSS.SSS.SSS.SSS.SSS.SSS.SSS.SS S.S S S.[RS S.4 nS [RS[R/4S .S SS[R/4S .S SS[R/4S .S SS[R/4S .S SS[R /4S .S SS[R /4S .S S[R[R /4S .S [RS [R /4S .S S S[R /4S .S SS[R /4S .4 nURX5 SUlSUl g)z A convenience routine for testing a complex, bi-directional scale. >>> net = scale.intervalNetwork.IntervalNetwork() >>> net.fillMelodicMinor() >>> [str(p) for p in net.realizePitch('c4')] ['C4', 'D4', 'E-4', 'F4', 'G4', 'A4', 'B4', 'C5'] rprrM2)r rum2TN) rr&r'r*r5r6r7rrr)rrrs rfillMelodicMinor IntervalNetwork.fillMelodicMinors! 2Q'Q'Q'Q'Q'Q'Q'Q' 3 ##+<<ILL"A!C##$a"6!8##$a"6!8##$a"6!8##$a)<)<"=!?##$a)<)<"=!?##$hmmY5H5H"I!K##+==!Y5I5I"J!L##$a)=)=">!@##$a)=)=">!@7@ 5(!%!rc[[[U555nUVs/sHoDRPM nn[R "X55nXX&4$s snf)a Perform weighted random selection on a parallel list of edges and corresponding nodes. >>> n1 = scale.intervalNetwork.Node(id=1, degree=1, weight=1000000) >>> n2 = scale.intervalNetwork.Node(id=2, degree=1, weight=1) >>> e1 = scale.intervalNetwork.Edge(interval.Interval('m3'), id=1) >>> e2 = scale.intervalNetwork.Edge(interval.Interval('m3'), id=2) >>> net = scale.intervalNetwork.IntervalNetwork() >>> e, n = net.weightedSelection([e1, e2], [n1, n2]) Note: this may fail as there is a slight chance to get 2 >>> e.id 1 >>> n.id 1 )listrangerrQrweightedSelection)rrriValuesrweightsrUs rr!IntervalNetwork.weightedSelectionsQ(uSZ()%*+U88U+  $ $W 6x!! ,sAcSnURR5H)nUcURnM[XR5nM+ U$)z Return the lowest degree value. >>> edgeList = ['M2', 'M2', 'm2', 'M2', 'M2', 'M2', 'm2'] >>> net = scale.intervalNetwork.IntervalNetwork() >>> net.fillBiDirectedEdges(edgeList) >>> net.degreeMin 1 N)rvaluesrminrxrs r degreeMinIntervalNetwork.degreeMin0C ""$AyHH88$ % rcSnURR5H)nUcURnM[XR5nM+ U$)z Return the largest degree value. >>> edgeList = ['M2', 'M2', 'm2', 'M2', 'M2', 'M2', 'm2'] >>> net = scale.intervalNetwork.IntervalNetwork() >>> net.fillBiDirectedEdges(edgeList) >>> net.degreeMax # returns eight, as this is the last node 8 N)rrrmaxrs r degreeMaxIntervalNetwork.degreeMaxCrrcSnURR5HAup#U[R:XaMUcURnM,[ XR5nMC U$)a Return the largest degree value that represents a pitch level that is not a terminus of the scale. >>> edgeList = ['M2', 'M2', 'm2', 'M2', 'M2', 'M2', 'm2'] >>> net = scale.intervalNetwork.IntervalNetwork() >>> net.fillBiDirectedEdges(edgeList) >>> net.degreeMaxUnique 7 N)ritemsrr'rr)rrnIdrs rdegreeMaxUniqueIntervalNetwork.degreeMaxUniqueVsT jj&&(FChmm#yHH88$)rcb/nURUR[R5 U$)a] Return a list of first Nodes, or Nodes that contain Terminus.LOW. >>> edgeList = ['M2', 'M2', 'm2', 'M2', 'M2', 'M2', 'm2'] >>> net = scale.intervalNetwork.IntervalNetwork() >>> net.fillBiDirectedEdges(edgeList) >>> net.terminusLowNodes [] Note that this list currently always has one element. )rerrr&rposts rterminusLowNodes IntervalNetwork.terminusLowNodesms' DJJx||,- rcb/nURUR[R5 U$)a( Return a list of last Nodes, or Nodes that contain Terminus.HIGH. >>> edgeList = ['M2', 'M2', 'm2', 'M2', 'M2', 'M2', 'm2'] >>> net = scale.intervalNetwork.IntervalNetwork() >>> net.fillBiDirectedEdges(edgeList) >>> net.terminusHighNodes [] )rerrr'rs rterminusHighNodes!IntervalNetwork.terminusHighNodess' DJJx}}-. rc([5nURR5Hiup4U(aOU[R:Xa+UR[R R X#'MKUR X#'M[UR X#'Mk U$)a. Return a dictionary of node-id, node-degree pairs. The same degree may be given for each node There may not be an unambiguous way to determine the degree. Or, a degree may have different meanings when ascending or descending. If `equateTermini` is True, the terminals will be given the same degree. )rrrrr'r&r)r equateTerminirrrs rgetNodeDegreeDictionary'IntervalNetwork.getNodeDegreeDictionarysj0;}jj&&(FC(--' $ 8<< 8 ? ?DI !DIHH ) rc*UR5nX!$)z Given a strict node id (the .id attribute of the Node), return the degree. There may not be an unambiguous way to determine the degree. Or, a degree may have different meanings when ascending or descending. )r)rrnodeSteps rnodeIdToDegreeIntervalNetwork.nodeIdToDegrees//1}rc/n[U[5(aUnURnOURUnURHmnURUnUR HKupgXa:XaUR UR5 MFXq:XdM/UR UR5 Mk Mo U(d [SU5eU$)a Given a Node id, find all edges associated with this node and report on their directions >>> net = scale.intervalNetwork.IntervalNetwork() >>> net.fillMelodicMinor() >>> net.nodeIdToEdgeDirections(scale.Terminus.LOW) [Direction.BI] >>> net.nodeIdToEdgeDirections(0) [Direction.BI, Direction.BI] >>> net.nodeIdToEdgeDirections(6) [Direction.ASCENDING, Direction.ASCENDING] >>> net.nodeIdToEdgeDirections(5) [Direction.DESCENDING, Direction.DESCENDING] This node has bi-directional (from below), ascending (to above), and descending (from above) edge connections connections >>> net.nodeIdToEdgeDirections(3) [Direction.BI, Direction.ASCENDING, Direction.DESCENDING] zfailed to match any edges) rMr}rRrrrurerPr)rr collectionnObjreObjrys rnodeIdToEdgeDirections&IntervalNetwork.nodeIdToEdgeDirectionss. c4 D''C::c?D::C::c?D((8%%dnn5X%%dnn5 )*+FM MrclUc [S5eURnURnX2- nUS- U-U-$)a1 Return the degree modulus degreeMax - degreeMin. >>> edgeList = ['M2', 'M2', 'm2', 'M2', 'M2', 'M2', 'm2'] >>> net = scale.intervalNetwork.IntervalNetwork() >>> net.fillBiDirectedEdges(edgeList) >>> net.degreeModulus(3) 3 >>> net.degreeModulus(8) 1 >>> net.degreeModulus(9) 2 >>> net.degreeModulus(0) 7 z%Degree of None given to degreeModulusrp)rrr)rrsMinsMax spanCounts r degreeModulusIntervalNetwork.degreeModulussF >*+RS S~~~~K !y(D00r)rpermitDegreeModulic[U[5(a/nURUS9nUR5H*upgX:XdM UR UR U5 M, U(dUU(aNUR5H:upgUR U5U:XdMUR UR U5 M< U$[U[5(aAU[R:Xa UR$U[R:Xa UR$g[U[5(a,UR HnUR UnXLdMU/s $ g[U[5(a[SU<S35e[SU35e)a The `nodeId` parameter may be a :class:`~music21.scale.intervalNetwork.Node` object, a node degree (as a number), a terminus string, or a None (indicating Terminus.LOW). Return a list of Node objects that match this identification. If `equateTermini` is True, and the name given is a degree number, then the first terminal will return both the first and last. >>> edgeList = ['M2', 'M2', 'm2', 'M2', 'M2', 'M2', 'm2'] >>> net = scale.intervalNetwork.IntervalNetwork() >>> net.fillBiDirectedEdges(edgeList) >>> net.nodeNameToNodes(1)[0] >>> net.nodeNameToNodes(scale.Terminus.HIGH) [] >>> net.nodeNameToNodes(scale.Terminus.LOW) [] Test using a nodeStep, or an integer nodeName >>> net.nodeNameToNodes(1) [, ] >>> net.nodeNameToNodes(1, equateTermini=False) [] >>> net.nodeNameToNodes(2) [] With degree moduli, degree zero is the top-most non-terminal (since terminals are redundant) >>> net.nodeNameToNodes(0) [] >>> net.nodeNameToNodes(-1) [] >>> net.nodeNameToNodes(8) [, ] )rz Strings like z are no longer valid nodeIds.zcannot filter by: N)rMrdrrrerrrr&rr'rr}rNr) rnodeIdrrrrrnSteprs rnodeNameToNodesIntervalNetwork.nodeNameToNodessQ\ fc " "D33+4-H&nn. ?KK 30/."*.."2JC))&1U: DJJsO4#3K  ) )%,,,8==(---)  % %zzJJsO;3J" $ $*]6*Da+bc c*-?x+HI Irc/n/nURnU[R:Xa%U[R:Xa[R nO8U[R :Xa$U[R :Xa[RnURH`nURUnURU5nU(dM,UH.upX:XdM URU5 URU 5 M0 Mb U(d&[RSUSUSU/5 [S5eUV s/sHoRU PM n n X<4$s sn f)a Given a Node, get two lists, one of next Edges, and one of next Nodes, searching all Edges to find all matches. There may be more than one possibility. If so, the caller must look at the Edges and determine which to use >>> edgeList = ['M2', 'M2', 'm2', 'M2', 'M2', 'M2', 'm2'] >>> net = scale.intervalNetwork.IntervalNetwork() >>> net.fillBiDirectedEdges(edgeList) >>> net.nodeNameToNodes(1)[0] nodeStartrPpostEdgezcould not find any edges)rRrr&r*r7r'r6rrqre environLocal printDebugrr) rr rPr  postNodeIdsrcIdkrpairssrcdstrpostNodes rgetNextIntervalNetwork.getNextJs   HLL Y)2F2F%FMME hmm # Y5H5H(HLLEA 1 A$$Y/E!<OOA&%%c* "   # #[)[)%/%; <++EF F0::zJJsOz:!!;s#EcU(dU$URU;aU$XRSnSnXE:XaSnOuU[R:Xa'U[R[R4;aSnO:U[R[R4;aU[R:XaSnU(a#UR XRSU5nU$U$)zh Return an altered pitch for given node, if an alteration is specified in the alteredDegrees dictionary rPFTr )rr*r5r6r7$transposePitchAndApplySimplification)ralteredDegreesrprP directionSpecmatchpPosts rprocessAlteredNodes#IntervalNetwork.processAlteredNodes}sH 88> )H&xx0=   %E9<<'I$7$79M9M#NNEI//1E1EFF9<</E ==xx(4a9ELrNrPrcU(dU$URU;a1URXBRSR5U5nU$U$)zW Given a node and alteredDegrees get the unaltered pitch, or return the current object r )rrreverse)rpitchObjnodeObjrPrrs rgetUnalteredPitch!IntervalNetwork.getUnalteredPitchsOO >>^ +99~~.z:BBDhPAHrrp)rPstepSizer getNeighborc Uc [S5e[U[5(a[R"U5nO[ R "U5nSn URUUUUUS9n Sn U ccUS[R[R[R4;a/Sn URUUUUS9upU[R:XaU n OU n URUUURU RUSSSS9nUR UlSnUR#U 5nU(aUU;aUUS R$nU (aU[R:XdU (dpU[R:Xa\UR bNUR'U5U:a9U=R S -slUR bUR'U5U:aM9O[UR bNUR'U5U:a9U=R S - slUR bUR'U5U:aM9URU n[)U5HnUR+UU5unn[-U5S :a"UR/UU5unnUR0nOUSR0nUSnU[R:XaUR3UU5nO UR3UR55U5nUR7UUUUS 9n M U $) aj Given a pitchReference, nodeName, and a pitch origin, return the next pitch. The `nodeName` parameter may be a :class:`~music21.scale.intervalNetwork.Node` object, a node degree, a Terminus Enum, or a None (indicating Terminus.LOW). >>> edgeList = ['M2', 'M2', 'm2', 'M2', 'M2', 'M2', 'm2'] >>> net = scale.intervalNetwork.IntervalNetwork() >>> net.fillBiDirectedEdges(edgeList) >>> net.nextPitch('g', 1, 'f#5', direction=scale.Direction.ASCENDING) >>> net.nextPitch('g', 1, 'f#5', direction=scale.Direction.DESCENDING) The `stepSize` parameter can be configured to permit different sized steps in the specified direction. >>> net.nextPitch('g', 1, 'f#5', ... direction=scale.Direction.ASCENDING, ... stepSize=2) Altered degrees can be given to temporarily change the pitches returned without affecting the network as a whole. >>> alteredDegrees = {2: {'direction': scale.Direction.BI, ... 'interval': interval.Interval('-a1')}} >>> net.nextPitch('g', 1, 'g2', ... direction=scale.Direction.ASCENDING, ... alteredDegrees=alteredDegrees) >>> net.nextPitch('g', 1, 'a-2', ... direction=scale.Direction.ASCENDING, ... alteredDegrees=alteredDegrees) Nz/No pitch origin for calling next on this pitch!)r pitchTargetrPrFT)pitchReferencenodeNamer)rP)r*r+nodeDegreeTargetrPminPitchmaxPitchrrr rprrrrP) TypeErrorrMrNr PitchcopydeepcopygetRelativeNodeIdr*r6r7r5getNeighborNodeIdsgetPitchFromNodeDegreerroctaver semitones transposerrrrr rr!r)rr*r+ pitchOriginrPr&rr'pitchOriginObjpCollectr usedNeighborlowIdhighIdralterSemitonesrrrUr rr intervalObjs r nextPitchIntervalNetwork.nextPitchsb  MN N k3 ' '"[[5N!]];7N''/74B2;7E (G ND)*=*=y?S?SU^UaUa#bbL 33>=E@N>G4IMEi222  ' ')!ZZ/66 (  "(($$V, f6+F3J?IIN kY-A-AA$i6I6I)I((&1;;~+F+WA ((&1;;~+F+W((&1;;~+F+WA ((&1;;~+F+W JJv xA!%a!; Hh8}q --hA1jj &qk22 QKI///==k1M==k>Q>Q>SUVW//~3434;D0FH'!0r)r!cUb URnOSnUb URnOSnURURUUUU4$)z6 Return key for caching based on critical components. N)nameWithOctaverR) rr#r*r-r. includeFirstr!minKeymaxKeys r _getCacheKeyIntervalNetwork._getCacheKey\sV  ,,FF  ,,FF --  r)rfillMinMaxIfNonec[U[5(a[R"U5nO[R "U5n[U[ 5(aUnO'UcURSnOURU5SnURcURUl [U[5(a[R"U5n[U[5(a[R"U5nU(aUcUcURUUUS9up4URUU[RUS9nUR(a2UR!UUUUSS9nXR";aUR"U$OSnUR$(aUbUR'USSS9 Un Un U n /n /n SnS nX:GaUS - nSnUbP[)U R*UR*5(a+Ub([-U R*UR*5(aSnOdUb+[)U R*UR*5(aUcSnO6Ub+[-U R*UR*5(aUcSnOUcUcSnU(a,U R/U 5 U R/U R05 Ub&[)U R*UR*5(aOU R0[2R4:XaUcOURSn UR7U [R5nUcOUunn[9U5S :a"UR;UU5unn UR<nOUSR<nUSn UR?UU 5n U n URAUU U [RS 9n X:aGMX:a [CS 5eUR(aUbX4UR"U'X4$) a Given a reference pitch, realize upwards to a maximum pitch. >>> edgeList = ['M2', 'M2', 'm2', 'M2', 'M2', 'M2', 'm2'] >>> net = scale.intervalNetwork.IntervalNetwork() >>> net.fillBiDirectedEdges(edgeList) >>> (pitches, nodeKeys) = net.realizeAscending('c2', 1, 'c5', 'c6') >>> [str(p) for p in pitches] ['C5', 'D5', 'E5', 'F5', 'G5', 'A5', 'B5', 'C6'] >>> nodeKeys [Terminus.HIGH, 0, 1, 2, 3, 4, 5, Terminus.HIGH] >>> net = scale.intervalNetwork.IntervalNetwork(octaveDuplicating=True) >>> net.fillBiDirectedEdges(edgeList) >>> (pitches, nodeKeys) = net.realizeAscending('c2', 1, 'c5', 'c6') >>> [str(p) for p in pitches] ['C5', 'D5', 'E5', 'F5', 'G5', 'A5', 'B5', 'C6'] >>> nodeKeys [Terminus.LOW, 0, 1, 2, 3, 4, 5, Terminus.HIGH] NrrrF)rFTminimizeinPlacedrpr/zrCannot realize these pitches; is your scale well-formed? (especially check if you're giving notes without octaves))"rMrNr r1r2r3r}rrr7implicitOctave realizeMinMaxr$r*r6rrIrrtransposeBelowTargetr?psrBrerRrr'rrrr rrr)rr*rr-r.rrKr#ckrrr<rr attempts maxAttempts appendPitch nextBundler rrrAs rrealizeAscending IntervalNetwork.realizeAscendingzs@ nc * *"[[8N!]]>:N fd # #G ^++A.G**6215G  ($2$A$AN ! h $ ${{8,H h $ ${{8,H  0X5E!%!3!3N4;CQ"4"S H //07:C:M:M?M0O   ""7#1#+#+05 #7B )))++B//*B  ! !h&:  / /4QU / V    $ MHK$X[[(++66 ,X[[(++66" &8;; 44&" &8;; 44&" !h&6"  H%!!!$$'#QTT8;;(?(?ttx}}$#))!,a)<)<=J!!+ Hh8}q --hA1jj &qk22 QK99+qIAH//~3434;D;N;N0PHm$v  "*[\ \   ".'+'7D  $r)rrFrKr!c LSn [U[5(a[R"U5n O[R "U5n U R cSU l[U[5(aUn O'UcURSn OURU5Sn [U[5(a[R"U5n OUn [U[5(a[R"U5n OUn U(aU cU cURU U US9upURU U [RUS9n UR(a2URU U U U UUS9n XR ;aUR U $UR"(aU bU R%U SSS9 U nU nUn/n/nSnS nU bP['UR(U R(5(a+U b([+UR(U R(5(aSnOdU b+['UR(U R(5(aU cSnO6U b+[+UR(U R(5(aU cSnOU cU cSnU(aU(aU(a:U(a3U(a,UR-U5 UR-UR.5 S nU bUR(U R(::aGOUR.[0R2:XaU cOUR4SnUR.[0R2:XaU cOUR7U[R5nUcOUunn[9U5S :a"UR;UU5unnUR<nOUSR<nUSnUR?URA5U5nURCUUU[RS 9nGM-U(a URA5 URA5 UR(aU bUU4UR U 'UU4$) a Given a reference pitch, realize downward to a minimum. If no minimum is given, the terminus is used. If `includeFirst` is False, the starting (highest) pitch will not be included. If `fillMinMaxIfNone` is True, a min and max will be artificially derived from an ascending scale and used as min and max values. >>> edgeList = ['M2', 'M2', 'm2', 'M2', 'M2', 'M2', 'm2'] >>> net = scale.intervalNetwork.IntervalNetwork() >>> net.fillBiDirectedEdges(edgeList) >>> net.realizeDescending('c2', 1, 'c3') # minimum is above ref ([], []) >>> (pitches, nodeKeys) = net.realizeDescending('c3', 1, 'c2') >>> [str(p) for p in pitches] ['C2', 'D2', 'E2', 'F2', 'G2', 'A2', 'B2'] >>> nodeKeys [Terminus.LOW, 0, 1, 2, 3, 4, 5] >>> (pitches, nodeKeys) = net.realizeDescending('c3', 1, 'c2', includeFirst=True) >>> [str(p) for p in pitches] ['C2', 'D2', 'E2', 'F2', 'G2', 'A2', 'B2', 'C3'] >>> nodeKeys [Terminus.LOW, 0, 1, 2, 3, 4, 5, Terminus.LOW] >>> (pitches, nodeKeys) = net.realizeDescending('a6', scale.Terminus.HIGH) >>> [str(p) for p in pitches] ['A5', 'B5', 'C#6', 'D6', 'E6', 'F#6', 'G#6'] >>> nodeKeys [Terminus.LOW, 0, 1, 2, 3, 4, 5] >>> (pitches, nodeKeys) = net.realizeDescending('a6', scale.Terminus.HIGH, ... includeFirst=True) >>> [str(p) for p in pitches] ['A5', 'B5', 'C#6', 'D6', 'E6', 'F#6', 'G#6', 'A6'] >>> nodeKeys [Terminus.LOW, 0, 1, 2, 3, 4, 5, Terminus.HIGH] >>> net = scale.intervalNetwork.IntervalNetwork(octaveDuplicating=True) >>> net.fillBiDirectedEdges(edgeList) >>> (pitches, nodeKeys) = net.realizeDescending('c2', 1, 'c0', 'c1') >>> [str(p) for p in pitches] ['C0', 'D0', 'E0', 'F0', 'G0', 'A0', 'B0'] >>> nodeKeys [Terminus.LOW, 0, 1, 2, 3, 4, 5] NrrrMr)r-r.rFr!TrNFrpr/)"rMrNr r1r2r3r7r}rrrSr$r*r7rrIrrtransposeAboveTargetr?rUrBrerRrr&rrrrr rr!r)rr*rr-r.rrFrKr!rVpitchRefr# minPitchObj maxPitchObjrrr<pre preNodeIdisFirstrYrZr rrrAs rrealizeDescending!IntervalNetwork.realizeDescendingsx nc * *{{>2H}}^4H ?? "HO fd # #G ^++A.G**6215G h $ $++h/K"K h $ $++h/K"K  3 8K'+'9'9(:AIW(:(Y $K ))(*14=4H4H9G*I   ""7#+,7,70<+2 #%B***,,R00  ! !k&=  ) )+d ) S   K'QTT;>>22#/QTT;>>22" )14400!)" )14400!)" $)<" G\ 8$  &G&144;>>+Attx||#&**1-ttx||#&a)=)=>J!!+ Hh8}q --hA1jj &qk22 QK99+:M:M:OQRSA//~2323:C:N:N0PHox  KKM       ".(+YD ! !" %I~rc rUc [S5e[U[5(a[R"U5nO[ R "U5nURcURUl[U[5(a[R"U5n OUn [U[5(a[R"U5n OUn Sn UR(aSn U (GaiU[R:Xa<UR(aU bURU SS9 URUUU U USS9upGOOU[R:Xa=UR(aU bURU SS9 UR!UUU U USSS9upGOU[R":XGa[ R "U5n[ R "U5nUR(aU bURU SS9 URUUU U US9unnUR(aU bURU SS9 UR!UUU U USS9unn/n/nS nS nS nUS :aUS -nU[%U5:a6UUU;a-UR'UU5 UR'UUUU45 US - nU[%U5:a6UUU;a-UR'UU5 UR'UUUU45 US - nU[%U5:aU[%U5:aOUS :aM/n /n UH(unnU R'U5 U R'U5 M* OE[S U<35eURUUU U US9unnUR!UUU U USS9unnUU-UU-pU(a([)[+U 55n [)[+U 55n X4$) aB Realize the nodes of this network based on a pitch assigned to a valid `nodeId`, where `nodeId` can be specified by integer (starting from 1) or key (a tuple of origin, destination keys). Without a min or max pitch, the given pitch reference is assigned to the designated node, and then both ascends to the terminus and descends to the terminus. The `alteredDegrees` dictionary permits creating mappings between node degree and direction and :class:`~music21.interval.Interval` based transpositions. Returns two lists, a list of pitches, and a list of Node keys. >>> edgeList = ['M2', 'M2', 'm2', 'M2', 'M2', 'M2', 'm2'] >>> net = scale.intervalNetwork.IntervalNetwork() >>> net.fillBiDirectedEdges(edgeList) >>> (pitches, nodeKeys) = net.realize('c2', 1, 'c2', 'c3') >>> [str(p) for p in pitches] ['C2', 'D2', 'E2', 'F2', 'G2', 'A2', 'B2', 'C3'] >>> nodeKeys [Terminus.LOW, 0, 1, 2, 3, 4, 5, Terminus.HIGH] >>> alteredDegrees = {7: {'direction': scale.Direction.BI, ... 'interval': interval.Interval('-a1')}} >>> (pitches, nodeKeys) = net.realize('c2', 1, 'c2', 'c4', alteredDegrees=alteredDegrees) >>> [str(p) for p in pitches] ['C2', 'D2', 'E2', 'F2', 'G2', 'A2', 'B-2', 'C3', 'D3', 'E3', 'F3', 'G3', 'A3', 'B-3', 'C4'] >>> nodeKeys [Terminus.LOW, 0, 1, 2, 3, 4, 5, Terminus.HIGH, 0, 1, 2, 3, 4, 5, Terminus.HIGH] zpitchReference cannot be NoneFTrP)r*rr-r.rrKr*rr-r.rrFrK)r*rr-r.r)r*rr-r.rrFri'rpz&cannot match direction specification: )rrMrNr r1r2r3r7rRrr*r6rTr[r7r^rer5rrerreversed)rr*rr-r.rPrr!r_r`radirectedRealization mergedPitches mergedNodespitchReferenceApitchReferenceBrr rbrcmerged foundPitchesrUjpreventPermanentRecursionrrs rrealizeIntervalNetwork.realizes Z  !*+JK K nc * *{{>2H}}^4H ?? "&55HO h $ $++h/K"K h $ $++h/K"K#  ! !"&  I///))k.E11+t1L-1-B-B#+!((#1%) .C.+* {i222))k.E11+t1L .2-C-C#+!((#1!%%).D.+* {ill*"&--"9"&--"9))k.E#88d8S$(#8#8@FBMBMHV $9$X j ))k.E#88d8S"&!7!7?EALALGUEI "8"KY! ,0)/!3-2-3t9}a )D$++DG4 tAw 1 &>?FA3s8|Al(B$++CF3 s1vy|&<=FACI~!s3x-0!3!#  "DAq!((+&&q)#/I>IDR 5 T D* "338;A=H=HCQAF 4HNC*-tY5K; !-!89Mx 45K))rc 6URUUUUUUUS9nUS$)a Realize the native nodes of this network based on a pitch assigned to a valid `nodeId`, where `nodeId` can be specified by integer (starting from 1) or key (a tuple of origin, destination keys). The nodeId, when a simple, linear network, can be used as a scale degree value starting from one. >>> edgeList = ['M2', 'M2', 'm2', 'M2', 'M2', 'M2', 'm2'] >>> net = scale.intervalNetwork.IntervalNetwork() >>> net.fillBiDirectedEdges(edgeList) >>> [str(p) for p in net.realizePitch(pitch.Pitch('G3'))] ['G3', 'A3', 'B3', 'C4', 'D4', 'E4', 'F#4', 'G4'] G3 is the fifth (scale) degree >>> [str(p) for p in net.realizePitch(pitch.Pitch('G3'), 5)] ['C3', 'D3', 'E3', 'F3', 'G3', 'A3', 'B3', 'C4'] G3 is the seventh (scale) degree >>> [str(p) for p in net.realizePitch(pitch.Pitch('G3'), 7) ] ['A-2', 'B-2', 'C3', 'D-3', 'E-3', 'F3', 'G3', 'A-3'] >>> [str(p) for p in net.realizePitch(pitch.Pitch('f#3'), 1, 'f2', 'f3') ] ['E#2', 'F#2', 'G#2', 'A#2', 'B2', 'C#3', 'D#3', 'E#3'] >>> [str(p) for p in net.realizePitch(pitch.Pitch('a#2'), 7, 'c6', 'c7')] ['C#6', 'D#6', 'E6', 'F#6', 'G#6', 'A#6', 'B6'] Circle of fifths >>> edgeList = ['P5'] * 6 + ['d6'] + ['P5'] * 5 >>> net5ths = scale.intervalNetwork.IntervalNetwork() >>> net5ths.fillBiDirectedEdges(edgeList) >>> [str(p) for p in net5ths.realizePitch(pitch.Pitch('C1'))] ['C1', 'G1', 'D2', 'A2', 'E3', 'B3', 'F#4', 'D-5', 'A-5', 'E-6', 'B-6', 'F7', 'C8'] >>> [str(p) for p in net5ths.realizePitch(pitch.Pitch('C2'))] ['C2', 'G2', 'D3', 'A3', 'E4', 'B4', 'F#5', 'D-6', 'A-6', 'E-7', 'B-7', 'F8', 'C9'] r*rr-r.rPrr!r)rt) rr*rr-r.rPrr! componentss r realizePitchIntervalNetwork.realizePitchs9l\\))" !}rc SnURUUUUUUUS9Sn/n [U5HEupU [U5S- :dMXS-n U R[R "X55 MG U $)a Realize the sequence of intervals between the specified pitches, or the termini. >>> edgeList = ['M2', 'M2', 'm2', 'M2', 'M2', 'M2', 'm2'] >>> net = scale.intervalNetwork.IntervalNetwork() >>> net.fillBiDirectedEdges(edgeList) >>> net.realizeIntervals() [, , , , , , ] c4rwrrp)rtrrrer rO) rrr-r.rPrr!r*pListiListrUp1p2s rrealizeIntervals IntervalNetwork.realizeIntervalss2 N$*&.&.'0,:%, . /0 1u%EA3u:>!q5\ X..r67& rctURUUUSS9SnURUUUSSS9SnXT-nUSUS4$)aC Realize the pitches of the 'natural' terminus of a network. This (presently) must be done by ascending, and assumes only one valid terminus for both extremes. This suggests that in practice termini should not be affected by directionality. >>> edgeList = ['M2', 'M2', 'm2', 'M2', 'M2', 'M2', 'm2'] >>> net = scale.intervalNetwork.IntervalNetwork() >>> net.fillBiDirectedEdges(edgeList) >>> net.realizeTermini(pitch.Pitch('G3')) (, ) >>> net.realizeTermini(pitch.Pitch('a6')) (, ) F)r*rrrKr)r*rrrFrK)r[re)rr*rrrrbrls rrealizeTerminiIntervalNetwork.realizeTerminis0$$))" %$%& ' $$))" %$ %& ' Qr!222rc URUUUS9upEURS5nURS5nURUUUUUSS9upgURUUUUUSSS9up/n Sn [ U5HupXlnU S:Xa&U [ R [ R4;aM5U [ R [ R4;aU SLaU RX45 OJU [ R [ R4;aU SLaSn U (dMU RX45 M /nSn [ U 5HupXnU S:Xa&U [ R [ R4;aM5U [ R [ R4;aU SLaURX45 OJU [ R [ R4;aU SLaSn U (dMURX45 M US nUSnX-H?upURUR:aUnURUR:dM=UnMA UU4$) a Realize the min and max pitches of the scale, or the min and max values found between two termini. This suggests that min and max might be beyond the terminus. >>> edgeList = ['M2', 'M2', 'm2', 'M2', 'M2', 'M2', 'm2'] >>> net = scale.intervalNetwork.IntervalNetwork() >>> net.fillBiDirectedEdges(edgeList) >>> net.realizeMinMax(pitch.Pitch('C4')) (, ) >>> net.realizeMinMax(pitch.Pitch('B-5')) (, ) Note that it might not always be two octaves apart # s = scale.AbstractDiatonicScale('major') # s._net.realizeMinMax(pitch.Pitch('D2')) # (, ) )r*rr F)r*rrr-r.rKTrirr) rr9r[rerrr&r'rerU)rr*rrlowhighrr rbrc postPairscollectrUrrprePairsr-r.s rrSIntervalNetwork.realizeMinMaxCs<8''~/57E(G  mmC ~~b!00))" 1$//))"0$  +FAAAv#(,, !>>x}}55'T/  !*x}}55'U:Jw  !*, *FAAAv#(,, !>>x}}55'T/)x}}55'U:Jw)+"87*FAtthkk!tthkk! +!!r)rpc .URUUUUUUS9upUV s/sHoRU 5PM n n /n [U5HHupURXnURUR5U ;dM7U R U5 MJ U $s sn f)au Realize the native nodes of this network based on a pitch assigned to a valid `nodeId`, where `nodeId` can be specified by integer (starting from 1) or key (a tuple of origin, destination keys). The `nodeDegreeTargets` specifies the degrees to be included within the specified range. Example: build a network of the Major scale: >>> edgeList = ['M2', 'M2', 'm2', 'M2', 'M2', 'M2', 'm2'] >>> net = scale.intervalNetwork.IntervalNetwork() >>> net.fillBiDirectedEdges(edgeList) Now for every "scale" where G is the 3rd degree, give me the tonic if that note is between C2 and C3. (There's only one such note: E-2). >>> net.realizePitchByDegree('G', 3, [1], 'c2', 'c3') [] But between c2 and f3 there are two, E-2 and E-3 (it doesn't matter that the G which is scale degree 3 for E-3 is above F3): >>> net.realizePitchByDegree('G', 3, [1], 'c2', 'f3') [, ] Give us nodes 1, 2, and 5 for scales where G is node 5 (e.g., C major's dominant) where any pitch is between C2 and F4 >>> pitchList = net.realizePitchByDegree('G', 5, [1, 2, 5], 'c2', 'f4') >>> print(' '.join([str(p) for p in pitchList])) C2 D2 G2 C3 D3 G3 C4 D4 There are no networks based on the major scale's edge-list where with node 1 (i.e. "tonic") between C2 and F2 where G is scale degree 7 >>> net.realizePitchByDegree('G', 7, [1], 'c2', 'f2') [] r*rr-r.rPr)rtrrrrre)rr*rnodeDegreeTargetsr-r.rPr realizedPitch realizedNodesnodeDegreeTargetsModulusrrUrrs rrealizePitchByDegree$IntervalNetwork.realizePitchByDegreesj'+ll)) '3'+# DU#UCTa$6$6q$9CT #Um,DA .sortTerminusLowThenIntThenTerminusHighsB I!S!!779. "I> !!"I> !rg?g333333?rL)rQstyle)keyposzgot degree count)networkx MultiDiGraphrrrPr*r6r7r5ruadd_edgerrrkeyssortrnoder r )rrrQrrg unused_eIdrrrrnKeysrrs rgetNetworkxGraph IntervalNetwork.getNetworkxGraphs\  "  ! ! #!ZZ--/MJ{{i111 4 44 ,MM 3F @*0"m TZZ__&' = >C 3Axx{*() HH%"-hh"7!BAFF3K   !Q & !  !3[ ABrc ~SSKJn URRUR 5S9nUR 5 g)z Given a method and keyword configuration arguments, create and display a plot. Requires `networkx` to be installed. * Changed in v8: other parameters were unused and removed. r)graph) networkxGraphN)music21r primitivesGraphNetworkxGraphrprocess)rkeywordsrrs rplotIntervalNetwork.plot* s7$ "    / ///1 0 3 rrU)comparisonAttributerPrc UcURSnOURU5Sn[U[5(a[R "U5nO.[U[ R5(a URnOUnURn U cURUlURSSS9n URSSS9n URUUU U UUS9up/n[X5H9unn[X5[X5:XdM UU;dM(URU5 M; U cSUlU(dg[U5S:XaUS$[ R""UUVs/sHnUR$UR&PM sn5$s snf) a Given a reference pitch assigned to node id, determine the relative node id of pitchTarget, even if displaced over multiple octaves The `nodeId` parameter may be a :class:`~music21.scale.intervalNetwork.Node` object, a node degree, a terminus string, or a None (indicating Terminus.LOW). Returns None if no match. If `getNeighbor` is True, or direction, the nearest node will be returned. If more than one node defines the same pitch, Node weights are used to select a single node. >>> edgeList = ['M2', 'M2', 'm2', 'M2', 'M2', 'M2', 'm2'] >>> net = scale.intervalNetwork.IntervalNetwork(edgeList) >>> net.getRelativeNodeId('a', 1, 'a4') Terminus.LOW >>> net.getRelativeNodeId('a', 1, 'b4') 0 >>> net.getRelativeNodeId('a', 1, 'c#4') 1 >>> net.getRelativeNodeId('a', 1, 'c4', comparisonAttribute='step') 1 >>> net.getRelativeNodeId('a', 1, 'c', comparisonAttribute='step') 1 >>> net.getRelativeNodeId('a', 1, 'b-4') is None True NrrFrhrr-r.rPrrp)rrrMrNr r1r Noter7rRr9rtziprrerrrrrQ)rr*rr)rrPrr#pitchTargetObj saveOctaver-r.realizedPitches realizedNodesrrrrs rr4!IntervalNetwork.getRelativeNodeIdB sX >++A.G**6215G k3 ' '"[[5N  TYY / /(..N(N#**  $2$A$AN !"++C+?!++B+>)-n6=?G?G@IES *6*U&+.+N 'M< <}BCt+KK -,O  $(N ! Y!^7N++DKO,P4aTZZ]-A-A4,PR R,Ps#F c UcURSnOURU5Sn[U[5(a[R "U5nOUnUR nUcURUlURSSS9n URSSS9n URUUU U UUS9upSn Sn[X5H)unnURUR:aUnX4s $Un M+ UcXlg)ad Given a reference pitch assigned to a node id, determine the node ids that neighbor this pitch. Returns None if an exact match. >>> edgeList = ['M2', 'M2', 'm2', 'M2', 'M2', 'M2', 'm2'] >>> net = scale.intervalNetwork.IntervalNetwork(edgeList) >>> net.getNeighborNodeIds('c4', 1, 'b-') (4, 5) >>> net.getNeighborNodeIds('c4', 1, 'b') (5, Terminus.HIGH) NrrFrhrr) rrrMrNr r1r7rRr9rtrrU)rr*r+r)rPrrr savedOctaver-r.rr lowNeighbor highNeighborrrs rr5"IntervalNetwork.getNeighborNodeIds s,  **1-F))(3A6F k3 ' '"[[5N(N$++  $2$A$AN !"++C+?!++B+>)-n6>> edgeList = ['M2', 'M2', 'm2', 'M2', 'M2', 'M2', 'm2'] >>> net = scale.intervalNetwork.IntervalNetwork(edgeList) >>> [str(p) for p in net.realizePitch(pitch.Pitch('e-2')) ] ['E-2', 'F2', 'G2', 'A-2', 'B-2', 'C3', 'D3', 'E-3'] >>> net.getRelativeNodeDegree('e-2', 1, 'd3') # if e- is tonic, what is d3 7 For an octave repeating network, the neither pitch's octave matters: >>> net.getRelativeNodeDegree('e-', 1, 'd5') # if e- is tonic, what is d3 7 >>> net.getRelativeNodeDegree('e-2', 1, 'd') # if e- is tonic, what is d3 7 >>> net.getRelativeNodeDegree('e3', 1, 'd5') is None True >>> net.getRelativeNodeDegree('e3', 1, 'd5', comparisonAttribute='step') 7 >>> net.getRelativeNodeDegree('e3', 1, 'd', comparisonAttribute='step') 7 >>> net.getRelativeNodeDegree('e-3', 1, 'b-3') 5 >>> net.getRelativeNodeDegree('e-3', 1, 'e-5') 1 >>> net.getRelativeNodeDegree('e-2', 1, 'f3') 2 >>> net.getRelativeNodeDegree('e-3', 1, 'b6') is None True >>> net.getRelativeNodeDegree('e-3', 1, 'e-2') 1 >>> net.getRelativeNodeDegree('e-3', 1, 'd3') 7 >>> net.getRelativeNodeDegree('e-3', 1, 'e-3') 1 >>> net.getRelativeNodeDegree('e-3', 1, 'b-1') 5 >>> edgeList = ['p4', 'p4', 'p4'] # a non octave-repeating scale >>> net = scale.intervalNetwork.IntervalNetwork(edgeList) >>> [str(p) for p in net.realizePitch('f2')] ['F2', 'B-2', 'E-3', 'A-3'] >>> [str(p) for p in net.realizePitch('f2', 1, 'f2', 'f6')] ['F2', 'B-2', 'E-3', 'A-3', 'D-4', 'G-4', 'C-5', 'F-5', 'A5', 'D6'] >>> net.getRelativeNodeDegree('f2', 1, 'a-3') # could be 4 or 1 1 >>> net.getRelativeNodeDegree('f2', 1, 'd-4') # 2 is correct 2 >>> net.getRelativeNodeDegree('f2', 1, 'g-4') # 3 is correct 3 >>> net.getRelativeNodeDegree('f2', 1, 'c-5') # could be 4 or 1 1 >>> net.getRelativeNodeDegree('f2', 1, 'e--6') # could be 4 or 1 1 >>> [str(p) for p in net.realizePitch('f6', 1, 'f2', 'f6')] ['G#2', 'C#3', 'F#3', 'B3', 'E4', 'A4', 'D5', 'G5', 'C6', 'F6'] >>> net.getRelativeNodeDegree('f6', 1, 'd5') 1 >>> net.getRelativeNodeDegree('f6', 1, 'g5') 2 >>> net.getRelativeNodeDegree('f6', 1, 'a4') 3 >>> net.getRelativeNodeDegree('f6', 1, 'e4') 2 >>> net.getRelativeNodeDegree('f6', 1, 'b3') 1 )r*rr)rrrPN)r4r)rr*rr)rrPrrs rgetRelativeNodeDegree%IntervalNetwork.getRelativeNodeDegree sG|$$)# 3) %! ;&&s+ +rc URU5n Sn URUSUS9n [U 5S:XaU Sn OgU V s/sHoRPM sn [R[R /:XaU Sn O#U Hn UR U 5nXN;dMU n O U cU Sn [S5HnURUU SUUUUS9unn[U5Hunn XR:Xa UUs s $U(dM'U [R [R4;dMMU R[R [R4;dM}UUs s $ M gs sn f)a| Given a reference pitch assigned to node id, determine the pitch for the target node degree. >>> edgeList = ['M2', 'M2', 'm2', 'M2', 'M2', 'M2', 'm2'] >>> net = scale.intervalNetwork.IntervalNetwork(edgeList) >>> [str(p) for p in net.realizePitch(pitch.Pitch('e-2')) ] ['E-2', 'F2', 'G2', 'A-2', 'B-2', 'C3', 'D3', 'E-3'] >>> net.getPitchFromNodeDegree('e4', 1, 1) >>> net.getPitchFromNodeDegree('e4', 1, 7) # seventh scale degree >>> net.getPitchFromNodeDegree('e4', 1, 8) >>> net.getPitchFromNodeDegree('e4', 1, 9) >>> net.getPitchFromNodeDegree('e4', 1, 3, minPitch='c2', maxPitch='c3') This will always get the lowest pitch: >>> net.getPitchFromNodeDegree('e4', 1, 3, minPitch='c2', maxPitch='c10') >>> net.fillMelodicMinor() >>> net.getPitchFromNodeDegree('c', 1, 5) >>> net.getPitchFromNodeDegree('c', 1, 6, scale.Direction.ASCENDING) >>> net.getPitchFromNodeDegree('c', 1, 6, scale.Direction.DESCENDING) NT)rrrpr r) rrrRrr&r'rrrtr)rr*r+r,rPr-r.rrnodeListForNames nodeTargetIdnodeTargetIdListrrdirListunused_counterrrrUs rr6&IntervalNetwork.getPitchFromNodeDegreeP sw\ //9 //0@CG>K0M  A %+A.L, -,qdd, -(,, 1N N+A.L'55c: '#&L(  ,A.L$BiN*.,,-'*!!#- +7+/ 'M<$L13//)(++!= ==*oo(--1NN,Q//2(;.sE)c"[U[[45(d2[U[5(a[R "U5nOUnU/nOX/nUHPn[U[5(a'UR [R "U55 M?UR U5 MR U(d [S5e[U5VVs/sHupEURU4PM nnnUR5 X&SSnX&SSnX'U4$s snnf)a Given a list or one pitch, check if all are pitch objects; convert if necessary. Return a 3-tuple: a list of all pitches, the min value and the max value. >>> Net = scale.intervalNetwork.IntervalNetwork >>> Net.filterPitchList(['c#4', 'f5', 'd3']) ([, , ], , ) A single string or pitch can be given. >>> Net.filterPitchList('c#') ([], , ) Empty lists raise value errors: >>> Net.filterPitchList([]) Traceback (most recent call last): ValueError: There must be at least one pitch given. * Changed in v8: staticmethod. Raise value error on empty z'There must be at least one pitch given.rrpr) rMrtuplerNr r1re ValueErrorrrUr) r)r" pitchListrrUr sortListr-r.s rfilterPitchListIntervalNetwork.filterPitchList s<+e}55+s++ ;;{3&! II a%%$$U[[^4$$Q' ! FG G3>> edgeList = ['M2', 'M2', 'm2', 'M2', 'M2', 'M2', 'm2'] >>> net = scale.intervalNetwork.IntervalNetwork(edgeList) >>> [str(p) for p in net.realizePitch('e-2')] ['E-2', 'F2', 'G2', 'A-2', 'B-2', 'C3', 'D3', 'E-3'] >>> net.match('e-2', 1, 'c3') # if e- is tonic, is 'c3' in the scale? ([], []) >>> net.match('e-2', 1, 'd3') ([], []) >>> net.match('e-2', 1, 'd#3') ([], []) >>> net.match('e-2', 1, 'e3') ([], []) >>> pitchTarget = [pitch.Pitch('b-2'), pitch.Pitch('b2'), pitch.Pitch('c3')] >>> net.match('e-2', 1, pitchTarget) ([, ], []) >>> pitchTarget = ['b-2', 'b2', 'c3', 'e-3', 'e#3', 'f2', 'e--2'] >>> (matched, unmatched) = net.match('e-2', 1, pitchTarget) >>> [str(p) for p in matched] ['B-2', 'C3', 'E-3', 'E#3', 'F2', 'E--2'] >>> unmatched [] rrMFT)rrrryrre)rr*rr)rrr-r. nodesRealizedmatchednoMatchtargetfoundrrs rrIntervalNetwork.match sT >**1-F))&1!4F*.*>*>{*K' x)).*0*2*29G *I "FE"12gf6ZZ E5NN6* E#5v&"rc :UcURSnOURU5SnURUUUUUS9n URU5up5n/n U HDn Sn UHn [ X5[ X5:XdMSn O U (aM3U R U 5 MF U $)a Find all pitches in the realized scale that are not in the pitch target network based on the comparison attribute. >>> edgeList = ['M2', 'M2', 'm2', 'M2', 'M2', 'M2', 'm2'] >>> net = scale.intervalNetwork.IntervalNetwork(edgeList) >>> [str(p) for p in net.realizePitch('G3')] ['G3', 'A3', 'B3', 'C4', 'D4', 'E4', 'F#4', 'G4'] >>> net.findMissing('g', 1, ['g', 'a', 'b', 'd', 'f#']) [, ] r)r-r.rFT)rrryrrre)rr*rr)rr-r.rPrrrrrrs r findMissingIntervalNetwork.findMissingR s, >**1-F))&1!4F)).*03;3;9G *I +/*>*>{*K' x#FE 12gf6ZZ E ! 5 F#$ r)CzC#zD-DzD#zE-EFzF#GzG#AzB-BzC-ztuple[str, ...] _SCALE_STARTSc (URSn/nURHHnURUUUUUS9upUR[ U5[ R "U545 MJ UR5 UR5 UbUSU$U$)a Given a collection of pitches, test all transpositions of a realized version of this network, and return the number of matches in each for each pitch assigned to the first node. >>> edgeList = ['M2', 'M2', 'm2', 'M2', 'M2', 'M2', 'm2'] >>> net = scale.intervalNetwork.IntervalNetwork(edgeList) a network built on G or D as >>> net.find(['g', 'a', 'b', 'd', 'f#']) [(5, ), (5, ), (4, ), (4, )] >>> net.find(['g', 'a', 'b', 'c', 'd', 'e', 'f#']) [(7, ), (6, ), (6, ), (5, )] If resultsReturned is None then return every such scale. r)rrN) rrrrerr r1rr!) rr)resultsReturnedrrrrrrunused_noMatchs rfindIntervalNetwork.find s4&&q) ##A'+jj$7- '1'/ #G OOS\5;;q>: ;$    &,_- -OrcURnUS;aC[US5(aUR(d[U[R 5(aSnUS:XaUR USS9nU$UR U5nUR(aMUS:XaURSS 9 U$US:XaURSSS 9 U$US;aU$[S US 3S -S-5eU$)a transposes the pitch according to the given interval object and uses the simplification of the `pitchSimplification` property to simplify it afterwards. >>> b = scale.intervalNetwork.IntervalNetwork() >>> b.pitchSimplification # default 'maxAccidental' >>> i = interval.Interval('m2') >>> p = pitch.Pitch('C4') >>> allPitches = [] >>> for j in range(15): ... p = b.transposePitchAndApplySimplification(i, p) ... allPitches.append(p.nameWithOctave) >>> allPitches ['D-4', 'D4', 'E-4', 'F-4', 'F4', 'G-4', 'G4', 'A-4', 'A4', 'B-4', 'C-5', 'C5', 'D-5', 'D5', 'E-5'] >>> b.pitchSimplification = 'mostCommon' >>> p = pitch.Pitch('C4') >>> allPitches = [] >>> for j in range(15): ... p = b.transposePitchAndApplySimplification(i, p) ... allPitches.append(p.nameWithOctave) >>> allPitches ['C#4', 'D4', 'E-4', 'E4', 'F4', 'F#4', 'G4', 'A-4', 'A4', 'B-4', 'B4', 'C5', 'C#5', 'D5', 'E-5'] PitchSimplification can also be specified in the creation of the IntervalNetwork object >>> b = scale.intervalNetwork.IntervalNetwork(pitchSimplification=None) >>> p = pitch.Pitch('C4') >>> allPitches = [] >>> for j in range(5): ... p = b.transposePitchAndApplySimplification(i, p) ... allPitches.append(p.nameWithOctave) >>> allPitches ['D-4', 'E--4', 'F--4', 'G---4', 'A----4'] Note that beyond quadruple flats or sharps, pitchSimplification is automatic: >>> p >>> b.transposePitchAndApplySimplification(i, p) )NnoneimplicitDiatonic mostCommon maxAccidentalrp)rsimplifyEnharmonicTrh)rPrz!unknown pitchSimplification type ,zG allowable values are "maxAccidental" (default), "simplifyEnharmonic", z!"mostCommon", or None (or "none")) rhasattrrrMr ChromaticIntervaltransposePitch accidentalrr)rrAr"rrs rr4IntervalNetwork.transposePitchAndApplySimplification sf#66 > 1+'9::{?[?[ X-G-GHH".  / 1..xq.IE  ..x8E&*>>,,T,: )L8,,Td,K )N:  3;?? r) rrrrrrrrr)r FTr)rz!Sequence[interval.Interval | str])rxz list[Node])T)rbool)rrdrxrd)rNode | int | Terminus | None)rx pitch.Pitch) r*pitch.Pitch | strr+rr:rrPr*r'zbool | Direction)r#r}r*rr-pitch.Pitch | Noner.rrFrr!z bool | NonerxCacheKey)NNN) r*rrrr-pitch.Pitch | str | Noner.rrxz.tuple[list[pitch.Pitch], list[Terminus | int]])r*rrrr-rr.r) r*str | pitch.Pitchrrr-rr.rrPr*) r*rrrr-rr.rrPr*rxzlist[pitch.Pitch]) rrr-rr.rrPr*rxzlist[interval.Interval])NN)r*rrrrxztuple[pitch.Pitch, pitch.Pitch]) r*rrrr-rr.rrPr*) r*rrrr)zpitch.Pitch | note.Note | strrrNrPr*)r*rr+rr)rrPr*)r*rr)rrPr*)r*rr+rrPr*)r)z7t.Union[list[str], list[pitch.Pitch], str, pitch.Pitch]rxz2tuple[list[pitch.Pitch], pitch.Pitch, pitch.Pitch])rN)r*r)r*rrPr*)rrN)rAzinterval.Intervalr"rrxr)7r!r"r#r$r%rVrr]rrrrrr{rrrrrrrrrrrrr*r5r$r6rBrIr[rertryrrrSrrrr4r5rr6 staticmethodrrrr__annotations__rrr(r rrrrs.>@#(#%4 #:#J .'>'>' > ' >  > >D*.)-)-(22(&('(' (  ( !(Z*. )3')3')3 ) )3\*. a"'a"'a" ) a"L*.)-)-(22I'I'I ' I ' IIV7r<$((22dR'dR'dR/ dR ! dRdRV )22 ;';);% ;  ;D!(22i,'i,% i,  i,` )22x0'x0)x0  x0z6-L6- ;6-6-x#/! J -J `)5!!+4+>+>#'1$31 )1h&M?!- 0dJ&JJ  Jrrc\rSrSrSrSrg)BoundIntervalNetworki zW This class is kept only because of the ICMC Paper. Just use IntervalNetwork instead. r N)r!r"r#r$r%r(r rrrr s  rr__main__)+r% __future__r collectionsrcollections.abcrr2enumtypingtrrrrr r r r Environmentr Enumrr*rrdrNrrr?rBMusic21ExceptionrDProtoM21ObjectrISlottedObjectMixinr}rrr _DOC_ORDERr!mainTestr rrrs2.##$  &&'>?  'tyy ' ( ( L#s4xT4d: < L11 J%7 ! !J%Z;!7 ! !6#<#<;!~ |<< ,x)x)vS ? tT *  z r