3jrdZddlmZddlmZddlmZddlZddlZddl Z ddl m Z ddl m Z ddl mZdd l mZdd l mZdd l mZdd l mZe j&d ZGddej*ZGddej*ZeeezeedzedzeedzfZdZdZGddej>Z GddejBZ"GddejBe jFZ$Gddej>Z%GddZ&Gdde&Z'e&e$e"gZ(e)d k(rddl Z e jTyy)!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$eZdZdZdZdZdZdZy)TerminuszU One of the two Termini of a scale, either Terminus.LOW or Terminus.HIGH terminusLow terminusHighc d|jzSNz Terminus.nameselfs J/DATA/.local/lib/python3.12/site-packages/music21/scale/intervalNetwork.py__repr__zTerminus.__repr__<TYY&&c d|jzSrrrs r__str__zTerminus.__str__?rrN)__name__ __module__ __qualname____doc__LOWHIGHrrrrrr4s C D''rrc(eZdZdZdZdZdZdZdZy) Directionz An enumerated Direction for a scale, either Direction.ASCENDING, Direction.DESCENDING, or Direction.BI (bidirectional) bi ascending descendingc d|jzSNz Direction.rrs rrzDirection.__repr__Kdii''rc d|jzSr*rrs rrzDirection.__str__Nr+rN) rrrr BI ASCENDING DESCENDINGrrr#rrr%r%Bs" BIJ((rr%c4||kDryt||z dkryy)z0 check if a > b or abs(a - b) < epsilon Th㈵>Fabsabs r_gter7V$ 1u QUg  rc4||kryt||z dkryy)z0 check if a < b or abs(a - b) < epsilon Tr1Fr2r4s r_lter:ar8rc eZdZy) EdgeExceptionNrrrr#rrr<r<lrr<ceZdZdZdej f d dZdZdZ d d dZ dZ d d dZ e dd Z y)Edgea6 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 Nct|trtj|}n|}||_||_d|_||_g|_y)N?) isinstancestrr Interval directionweightid _connections)r intervalDatarHrFis r__init__z Edge.__init__sK lC (!!,/AA+, $- FHrcdt||jxr|j|jk(S)aY >>> 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 )rC __class____dict__rothers r__eq__z Edge.__eq__s,5$..14MMU^^3 5rcf|jd|jjd|jS)N )rFr rrIrs r _reprInternalzEdge._reprInternals0..!4==#5#5"6a8I8I7LMMrc:t|ttfr|}n |j}t|ttfr|}n |j}|jj ||f|t jt jfvr td||_ y)a 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) rCrintrHrIappendr%r.r/r<rF)rnode1node2rFn1Idn2Ids raddDirectedConnectionzEdge.addDirectedConnections8 eh_ -D88D eh_ -D88D   $. Y00)2F2FG G :; ;"rc|j||tj|j||tjtj|_y)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)r]r%r.r/r-rF)rrYrZs raddBiDirectedConnectionszEdge.addBiDirectedConnectionss?$ ""5%1D1DE ""5%1E1EF"rc| |j}|j|k(r |jS|tjk(r7|jtjtj fvr t d|tjtj fvrc|jtjk(rF|tjk(r|jdgS|tj k(r|jdgSgS)aP 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)rFrIr%r-r.r/r<)rrFs rgetConnectionszEdge.getConnectionss2  I >>Y &$$ $  %NNy':':I>> 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 )rqrPs rrRz Node.__eq__as(DzT%[((rc d|jS)Nzid=rHrs rrUzNode._reprInternalwsTWWK  rN)rB)rHzTerminus | intrnrWrGfloat) rrrr __slots__rLrsrRrUr#rrrlrl=s" +I $),!rrlc eZdZy)IntervalNetworkExceptionNr=r#rrrzrz|r>rrzc0eZdZUdZ d; dd?dZdZdZd@dZddd dAdZdZdZej4dd dBdZej8dddd dCdZdd dDd Z dEddd! dFd"Z dEddddd# dGd$Z dddej8ddf dHd%Z!dddej8ddf dId&Z"dddej8ddf dJd'Z# dK dLd(Z$ dK dLd)Z%dd*ddej8df dMd+Z&d,ej8dd- dNd.Z'ej8df dOd/Z(d,ej8df dPd0Z)ej8ddddf dQd1Z*e+ dRd2Z, dS dTd4Z-d3ddej8df dUd5Z.d6Z/d7e0d8< dVd9Z1 dWd:Z2y)XIntervalNetworkat 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. FTcd|_d|_t|_t|_|r|j |||_||_||_t|_ t|_ y)Nr) edgeIdCount nodeIdCountredgesnodesfillBiDirectedEdgesoctaveDuplicating deterministicpitchSimplification_ascendingCache_descendingCache)redgeListrrrs rrLzIntervalNetwork.__init__sw7Bm 7Bm   $ $X ."3*$7 M  M rcd|_d|_t|_t|_t|_t|_y)z7 Remove and reset all Nodes and Edges. rN)r~rrrrrrrs rclearzIntervalNetwork.clears: ]  ] *} + rcvt||jsydD]}t||t||k7syy)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)r~rrrrrrT)rCrNgetattr)rrQattrs rrRzIntervalNetwork.__eq__sA,%0RDtT"geT&::Rrcl|jd}ttj|}|dz }||j|j <|}t |D]\}}|t|dz kr4t|j|}|xjdz c_|dz }|}nttj|} | }||j|j <t||j} | |j| j <|xjdz c_ | j|||}y)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'] rarHrnrvN)rrlrr!rrH enumeratelenrr"r@r~rr_) rr degreeCountnLow nPreviousrKeNamen nFollowingnHighes rrz#IntervalNetwork.fillBiDirectedEdgessf  x||K8q " 477 !(+HAu3x=1$$D,,[A  A% q   kB" )3DJJz}} %Ut//0A DJJqtt     !  & &y* ="I/,rc|jt|t|k7r tdd}ttj |}|dz }||j |j<|}t|D]\}}|t|dz kr4t|j|}|xjdz c_ |dz }|} nttj|} | } | |j | j<t||j} | |j| j<|xjdz c_ | j|| tj | }d}|j tj }|dz }|}t|D]\}}|t|dz krMt|j|}|xjdz c_ |dz }|} | |j | j<n|j tj} | } t||j} | |j| j<|xjdz c_ | j| |tj"| }y)a6 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 edgesrarrvrFN)rrrzrlrr!rrHrrr"r@r~rr]r%r.r/) rascendingEdgeListdescendingEdgeListrrrrKrrrrrs rfillDirectedEdgesz!IntervalNetwork.fillDirectedEdgesLsM   !S);%< <*+WX X x||K8q " 477 !"34HAu3()A--D,,[A  A% q   kB" )3DJJz}} %Ut//0A DJJqtt     !  # #Iz.7.A.A $ C#I/56 zz(,,'q  !"45HAu3)*Q..D,,[A  A% q  ,6 :==) 8==1" Ut//0A DJJqtt     !   # #J YEYEY # Z"I-6rc |j|D]<}t|d|d}d|vr |d|_||j|j<>d}|D]}t |d|}|dD]t\}} } | t jk(r-|j|j||j| G|j|j||j| | v||j|j<|d z }y ) a9 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) [, , ] rHrnrrGrr rvrerraN) rrlrGrrHr@r%r-r_r]r) rrrnDictreIdeDictrnId1nId2rFs r fillArbitraryzIntervalNetwork.fillArbitrarysL Ed E(O !DJJqtt  1HCrc tjdddddddddddddddddddddd dd d dtjd df }d tjdtjgfd d ddtjgfd d ddtjgfd d ddtjgfd d ddtj gfd d ddtj gfd d dtjtj gfd d tjd tj gfd d d dtj gfd d ddtj gfd f }|j||d|_d|_ y)a! 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'] rarrM2)r rem2TN) rr!r"r%r-r.r/rrr)rrrs rfillMelodicMinorz 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%(!%!rcttt|}|Dcgc]}|j}}t j ||}||||fScc}w)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 )listrangerrGrweightedSelection)rrriValuesrweightsrKs rrz!IntervalNetwork.weightedSelectionsY(uSZ()%*+U188U+  $ $Wg 6Qxq!! ,sAcd}|jjD]'}| |j}t||j})|S)a Return the lowest degree value. >>> edgeList = ['M2', 'M2', 'm2', 'M2', 'M2', 'M2', 'm2'] >>> net = scale.intervalNetwork.IntervalNetwork() >>> net.fillBiDirectedEdges(edgeList) >>> net.degreeMin 1 N)rvaluesrnminrxrs r degreeMinzIntervalNetwork.degreeMin-E ""$AyHH188$ % rcd}|jjD]'}| |j}t||j})|S)a. 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)rrrnmaxrs r degreeMaxzIntervalNetwork.degreeMax@rrcd}|jjD]>\}}|tjk(r| |j})t ||j}@|S)aQ 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"rnr)rrnIdrs rdegreeMaxUniquezIntervalNetwork.degreeMaxUniqueSsX jj&&(FChmm#yHH188$)rcbg}|j|jtj|S)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. )rXrrr!rposts rterminusLowNodesz IntervalNetwork.terminusLowNodesjs' DJJx||,- rcbg}|j|jtj|S)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 [] )rXrrr"rs rterminusHighNodesz!IntervalNetwork.terminusHighNodes|s' DJJx}}-. rct}|jjD]d\}}|rN|tjk(r+|jtj j ||<F|j ||<V|j ||<f|S)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!rn)r equateTerminirrrs rgetNodeDegreeDictionaryz'IntervalNetwork.getNodeDegreeDictionarysr0;}jj&&(FC(--' $ 8<< 8 ? ?DI !DIHHS ) rc,|j}||S)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 rnodeIdToDegreezIntervalNetwork.nodeIdToDegrees//1}rcrg}t|tr|}|j}n|j|}|jD]i}|j|}|j D]I\}}||k(r|j |jF||k(s.|j |jik|s td||S)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) rCrlrHrrrerXrFrz)rr collectionnObjreObjrys rnodeIdToEdgeDirectionsz&IntervalNetwork.nodeIdToEdgeDirectionss. c4 D''C::c?D::C::c?D((18%%dnn5#X%%dnn5 )*+FM Mrcl| td|j}|j}||z }|dz |z|zS)a 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 degreeModulusra)rzrr)rrnsMinsMax spanCounts r degreeModuluszIntervalNetwork.degreeModulussH >*+RS S~~~~4K !y(D00r)rpermitDegreeModulict|trg}|j|}|jD])\}}||k(s |j |j |+|sM|rK|jD]8\}}|j ||k(s|j |j |:|St|tr?|tjk(r |jS|tjk(r |jSyt|tr*|j D]}|j |}||us|gcSyt|trtd|dtd|)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)rCrWrrrXrrrr!rr"rrlrDrz) rnodeIdrrrrrnSteprs rnodeNameToNodeszIntervalNetwork.nodeNameToNodessM\ fc "D33+4-H&nn. UU?KK 30/."*.."2JC))&1U: DJJsO4#3K  )%,,,8==(---)  %zzJJsO;3J" $*]6*Da+bc c*-?x+HI Ircbg}g}|j}|tjk(r$|tjk(rtj }n6|tj k(r#|tj k(rtj}|jD]W}|j|}|j|}|s&|D]-\} } | |k(s |j||j| /Y|s&tjd|d|d|gtd|D cgc]} |j| } } || fScc} w)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] nodeStartrFpostEdgezcould not find any edges)rHrr!r%r/r"r.rrbrX environLocal printDebugrzr) rrrFr postNodeIdsrcIdkrpairssrcdstrpostNodes rgetNextzIntervalNetwork.getNextGs    HLL Y)2F2F%FMME hmm # Y5H5H(HLLEA 1 A$$Y/E!S%<OOA&%%c* "   # #[)[)%/%; <++EF F0::zDJJsOz:!!;sD,c|s|S|j|vr|S||jd}d}||k(rd}no|tjk(r%|tjtjfvrd}n7|tjtjfvr|tjk(rd}|r$|j ||jd|}|S|S)z Return an altered pitch for given node, if an alteration is specified in the alteredDegrees dictionary rFFTr )rnr%r-r.r/$transposePitchAndApplySimplification)ralteredDegreesrprF directionSpecmatchpPosts rprocessAlteredNodesz#IntervalNetwork.processAlteredNodeszsH 88> )H&qxx0=   %E9<<'I$7$79M9M#NNEI//1E1EFF9<</E ==qxx(4a9ELrNrFrc|s|S|j|vr2|j||jdj|}|S|S)zg Given a node and alteredDegrees get the unaltered pitch, or return the current object r )rnrreverse)rpitchObjnodeObjrFrrs rgetUnalteredPitchz!IntervalNetwork.getUnalteredPitchsQO >>^ +99w~~.z:BBDhPAHrra)rFstepSizer getNeighborc | tdt|trtj|}nt j |}d} |j|||||} d} | d|dtjtjtjfvr2d} |j||||\} } |tjk(r| } n| } |j|||j| j|ddd}|j |_d}|j#| }|r||vr||d j$}| r|tjk(s| sj|tjk(rW|j |j'||kDr|xj d zc_|j l|j'||kDr6nV|j J|j'||kr6|xj d z c_|j |j'||kr6|j| }t)|D]}|j+||\}}t-|d kDr"|j/||\}}|j0}n|dj0}|d}|tjk(r|j3||}n |j3|j5|}|j7|||| } | S) aQ 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 pitchTargetrFrFT)pitchReferencenodeNamerrF)rrnodeDegreeTargetrFminPitchmaxPitchrrr rarrrrF) TypeErrorrCrDr PitchcopydeepcopygetRelativeNodeIdr%r.r/r-getNeighborNodeIdsgetPitchFromNodeDegreerrnoctaver semitones transposerrrrr rrr)rrr pitchOriginrFrrrpitchOriginObjpCollectr usedNeighborlowIdhighIdralterSemitonesrnrrKrrr intervalObjs r nextPitchzIntervalNetwork.nextPitchs`  MN N k3 '"[[5N!]];7N''/74B2;7E (G ND)*=*=y?S?SU^UaUa#bbL 33>=E@N>G4IME6i222  ' ')!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)rc~| |j}nd}| |j}nd}|j|j||||fS)zF Return key for caching based on critical components. N)nameWithOctaverH) rrrrr includeFirstrminKeymaxKeys r _getCacheKeyzIntervalNetwork._getCacheKeyXsV  ,,FF  ,,FF --  r)rfillMinMaxIfNonec$t|trtj|}nt j |}t|t r|}n&||jd}n|j|d}|j|j|_ t|trtj|}t|trtj|}|r|||j|||\}}|j||tj|}|jr3|j!||||d}||j"vr|j"|Sd}|j$r||j'|dd|} |} | } g} g} d}d }||kr|d z }d}|Et)| j*|j*r%|#t-| j*|j*rd}nT|%t)| j*|j*r|d}n-|%t-| j*|j*r|d}n||d}|r,| j/| | j/| j0|!t)| j*|j*rn| j0t2j4k(r|n|jd} |j7| tj}|n|\}}t9|d kDr"|j;||\}} |j<}n|dj<}|d} |j?|| } | } |jA|| | tj } ||kr||k\r tCd |jr|| | f|j"|<| | fS) aj 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)rTminimizeinPlacedrarzrCannot realize these pitches; is your scale well-formed? (especially check if you're giving notes without octaves))"rCrDr rrr rlrrr implicitOctave realizeMinMaxrr%r.rrrrtransposeBelowTargetr7psr:rXrHrr"rrrr rrrz)rrrrrrrrckrrrrrattempts maxAttempts appendPitch nextBundlerrrrs rrealizeAscendingz IntervalNetwork.realizeAscendingvs@ nc *"[[8N!]]>:N fd #G ^++A.G**6215G  ($2$A$AN ! h ${{8,H h ${{8,H  0X5E!%!3!3N4;CQ"4"S Hh //07:C:M:M?M0O   ""7#1#+#+05 #7B T)))++B//B  ! !h&:  / /4QU / V    $ MHK$X[[(++6 ,X[[(++6" &8;; 4&" &8;; 4&" !h&6"  H%!!!$$'#QTT8;;(?ttx}}$#))!,a)<)<=J!!+ Hh8}q --hA1jj &qk22 QK99+qIAH//~3434;D;N;N0PHm$v { "*[\ \   ".'+Z'7D  $Zr)rrrrcd} t|trtj|} nt j |} | j d| _t|tr|} n&||jd} n|j|d} t|trtj|} n|} t|trtj|} n|} |r| | |j| | |\} } |j| | tj|} |jr4|j| | | | ||} | |j vr|j | S|j"r| | j%| dd| }| }|}g}g}d} d }| Et'|j(| j(r%| #t+|j(| j(rd}nT| %t'|j(| j(r| d}n-| %t+|j(| j(r| d}n| | d}|r|r|r0|r.|r,|j-||j-|j.d }| |j(| j(krn|j.t0j2k(r| n|j4d}|j.t0j2k(r| n|j7|tj}|n|\}}t9|d kDr"|j;||\}}|j<}n|dj<}|d}|j?|jA|}|jC|||tj }|r |jA|jA|jr| ||f|j | <||fS) 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] Nrrr!r)rrrrTr"Frar)"rCrDr rrr r rlrrr'rr%r/rrrrtransposeAboveTargetr7r)r:rXrHrr!rrrrr rrr)rrrrrrrrrr*pitchRefr minPitchObj maxPitchObjrrrpre preNodeIdisFirstr-r.rrrrs rrealizeDescendingz!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 #%BT***,,R00  ! !k&=  ) )+d ) S   K'QTT;>>2#/QTT;>>2" )1440!)" )1440!)" $)<" 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 | tdt|trtj|}nt j |}|j|j|_t|trtj|} n|} t|trtj|} n|} d} |jrd} | rX|tjk(r=|jr| |j| d|j||| | |d\} } nE|tjk(r>|jr| |j| d|j!||| | |dd\} } n|tj"k(rt j |}t j |}|jr| |j| d|j||| | |\}}|jr| |j| d|j!||| | |d\}}g}g}d }d }d }|d kDr|d z}|t%|kr4|||vr-|j'|||j'||||f|d z }|t%|kr4|||vr-|j'|||j'||||f|d z }|t%|k\r|t%|k\rn|d kDrg} g} |D]'\}}| j'|| j'|)nKtd ||j||| | |\}}|j!||| | |d\}}||z||z} } |r(t)t+| } t)t+| } | | fS) a 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 NoneFTr$)rrrrrrrrrrrrr)rrrrr)rrrrrrri'raz&cannot match direction specification: )rzrCrDr rrr r r&rr%r.r(r/r/r1r8r-rrXrreversed)rrrrrrFrrr2r3r4directedRealization mergedPitches mergedNodespitchReferenceApitchReferenceBrrr5r6merged foundPitchesrKjpreventPermanentRecursionrrs rrealizezIntervalNetwork.realizesZ  !*+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;M !-!89Mx 45Kk))rc <|j|||||||}|dS)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'] rrrrrFrrr)rF) rrrrrrFrr componentss r realizePitchzIntervalNetwork.realizePitchs9f\\))" !}rc d}|j|||||||d}g} t|D]D\} } | t|dz ks|| dz} | jt j | | F| S)a4 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() [, , , , , , ] c4rHrra)rFrrrXr rE) rrrrrFrrrpListiListrKp1p2s rrealizeIntervalsz IntervalNetwork.realizeIntervalss2 N$*&.&.'0,:%, . /0 1u%EAr3u:>!1q5\ X..r267& rc|j|||dd}|j|||ddd}||z}|d|dfS)a 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)rrrrr)rrrrr)r/r8)rrrrrr5r>s rrealizeTerminizIntervalNetwork.realizeTerminis0$$))" %$%& ' $$))" %$ %& 'd Qr!222rc v|j|||\}}|jd}|jd}|j|||||d\}}|j|||||dd\}} g} d} t |D]\} } || }| dk(r#| t j t jfvr3| t j t jfvr| dur| j|| fn@| t j t jfvr| durd} | s| j|| fg}d} t | D]\} } || }| dk(r#| t j t jfvr3| t j t jfvr| dur|j|| fn@| t j t jfvr| durd} | s|j|| f|d }|d}| |zD]<\}}|j|jkr|}|j|jkDs;|}>||fS) a1 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')) # (, ) )rrr F)rrrrrrTr;rrS) rTrr/r8rrr!r"rXr))rrrrlowhighrrr5r6 postPairscollectrKrrprePairsrr_nIds rr'zIntervalNetwork.realizeMinMax<sR8''~/57E(G T mmC ~~b!00))" 1$j//))"0$Y=?  +FAsQAAv#(,, !>>x}}55'T/  !S*x}}55'U:J  !S*,<> *FAsAAAv#(,, !>>x}}55'T/C)x}}55'U:JC)+"87 8+GAttthkk!tthkk! ,!!r)rac,|j||||||\}} |D cgc]} |j| } } g} t|D]F\} }|j| | }|j|j| vs6| j |H| Scc} w)ae 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') [] rrrrrFr)rFrrrrnrX)rrrnodeDegreeTargetsrrrFr realizedPitch realizedNodesnodeDegreeTargetsModulusrrKrrs rrealizePitchByDegreez$IntervalNetwork.realizePitchByDegreesj'+ll)) '3'+# |DU#UCTaD$6$6q$9CT #Um,DAq <?+A!!!((+/GG A -  $VsBr))comparisonAttributerFrc||jd}n|j|d}t|trt j |}n)t|t jr |j}n|}|j} | |j|_|jdd} |jdd} |j||| | ||\} } g}t| | D]5\}}t||t||k(s ||vs%|j|7| d|_|syt|dk(r|dSt!j"||Dcgc]}|j$|j&c}Scc}w) ag 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 NrrVFr:rWrrrFrra)rrrCrDr rr Noter r&rrFziprrXrrrrrG)rrrrrfrFrrpitchTargetObj saveOctaverrrealizedPitches realizedNodesrrarbrs rr z!IntervalNetwork.getRelativeNodeIdsV >++A.G**6215G k3 '"[[5N  TYY /(..N(N#**  $2$A$AN !"++C+?!++B+>)-n6=?G?G@IES *6*U&+. +N 'M< (;<}.ABCt+KK -,O  $(N ! Y!^7N++DKO,P4aTZZ]-A-A4,PR R,Ps E5 c||jd}n|j|d}t|trt j |}n|}|j }||j|_|jdd} |jdd} |j||| | ||\} } d} d}t| | D](\}}|j|jkr|}| |fcS|} *|||_y)a 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) NrrVFr:rWrh) rrrCrDr rr r&rrFrjr))rrrrrFrrrk savedOctaverrrmrn lowNeighbor highNeighborrarbs rr z"IntervalNetwork.getNeighborNodeIdsO 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 )rrrrfrrFN)r r)rrrrrfrFrrs rgetRelativeNodeDegreez%IntervalNetwork.getRelativeNodeDegree sGx$$)# 3) %! ;&&s+ +rc |j|} d} |j|d|} t| dk(r| d} na| D cgc]} | jc} tjtj gk(r| d} n | D]} |j | }||vs| } n| | d} tdD]}|j|| d||||\}}t|D]x\}} | | jk(r ||ccS|s!| tj tjfvsD| jtj tjfvsq||ccSycc} w)aS 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)rrrar r_) rrrHrr!r"rrrFr)rrrrrFrrrrnodeListForNames nodeTargetIdnodeTargetIdListrrdirListunused_counterrarbrKs rr z&IntervalNetwork.getPitchFromNodeDegree s{Z //9 //0@CG>K0M  A %+A.L, -,qadd, -(,, 1N N+A.L'55c: '#&L(  ,A.L$BiN*.,,-'*!!#- +7+/ 'M<$L13,//)(++! ==*oo(--1NN,Q//2(;.sEct|ttfs,t|trt j |}n|}|g}nOg}|D]H}t|tr%|j t j |8|j |J|s tdt|Dcgc]\}}|j|f}}}|j||dd}||dd}|||fScc}}w)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.rrarS) rCrtuplerDr rrX ValueErrorrr)sort) rr pitchListrrKr sortListrrs rfilterPitchListzIntervalNetwork.filterPitchListq s<+e}5+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 [] rr!FT)rrrrJrrX)rrrrrfrrr nodesRealizedmatchednoMatchtargetfoundrrs rrzIntervalNetwork.match sT >**1-F))&1!4F*.*>*>{*K' Xx)).*0*2*29G *I "FE"112gfFY6ZZ ENN6* E#v&"rc .||jd}n|j|d}|j|||||} |j|\}}}g} | D]<} d} |D]} t | |t | |k(sd} n| r,| j | >| S)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)rrrFT)rrrJrrrX)rrrrrfrrrFrrrrrrs r findMissingzIntervalNetwork.findMissing s, >**1-F))&1!4F)).*03;3;9G *I +/*>*>{*K' Xx#FE 112gfFY6ZZ E !  F#$ r)CzC#zD-DzD#zE-EFzF#GzG#AzB-BzC-ztuple[str, ...] _SCALE_STARTSc(|jd}g}|jD]J}|j|||||\}} |jt |t j |fL|j|j||d|S|S)aB 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)rfrN) rrrrXrr rrr) rrresultsReturnedrfrrrrrunused_noMatchs rfindzIntervalNetwork.find3 s2&&q) ##A'+jj$7- '1'/ #G^ OOS\5;;q>: ;$    &,_- -Orc|j}|dvr4t|dr |jst|tj rd}|dk(r|j |d}|S|j |}|jrO|dk(r|jd |S|dk(r|jdd |S|dvr |Std |d d zdz|S)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 maxAccidentalra)rsimplifyEnharmonicTr:)r$rz!unknown pitchSimplification type ,zG allowable values are "maxAccidental" (default), "simplifyEnharmonic", z!"mostCommon", or None (or "none")) rhasattrrrCr ChromaticIntervaltransposePitch accidentalrrz)rrrrrs rrz4IntervalNetwork.transposePitchAndApplySimplificationd sf#66 > 1+'9:{?[?[ X-G-GH".  / 1..xq.IE  ..x8E&*>>,,T,: )L8,,Td,K )N:  3;?? r)r#FTr)rz!Sequence[interval.Interval | str])rgz list[Node])T)rbool)rnrWrgrW)rNode | int | Terminus | None)rg pitch.Pitch) rpitch.Pitch | strrrrrrFr%rzbool | Direction)rrlrrrpitch.Pitch | Nonerrrrrz bool | NonergCacheKey)NNN) rrrrrpitch.Pitch | str | Nonerrrgz.tuple[list[pitch.Pitch], list[Terminus | int]])rrrrrrrr) rstr | pitch.PitchrrrrrrrFr%) rrrrrrrrrFr%rgzlist[pitch.Pitch]) rrrrrrrFr%rgzlist[interval.Interval])NN)rrrrrgztuple[pitch.Pitch, pitch.Pitch]) rrrrrrrrrFr%) rrrrrzpitch.Pitch | note.Note | strrfrDrFr%)rrrrrrrFr%)rrrrrFr%)rrrrrFr%)rz7t.Union[list[str], list[pitch.Pitch], str, pitch.Pitch]rgz2tuple[list[pitch.Pitch], pitch.Pitch, pitch.Pitch])rN)rr)rrrFr%)rrN)rzinterval.Intervalrrrgr)3rrrr rLrrRrrrrrrjrrrrrrrrrrrrr%r-rr.rrr/r8rFrJrQrTr'rer r rtr  staticmethodrrrr__annotations__rrr#rrr|r|s.>@#(#%4 #:#J .+>#'1$31 )1h&M?!- /bJ&JJ  Jrr|ceZdZdZy)BoundIntervalNetworkz_ This class is kept only because of the ICMC Paper. Just use IntervalNetwork instead. N)rrrr r#rrrr s  rr__main__)+r __future__r collectionsrcollections.abcrrenumtypingtmusic21rrrr r r r EnvironmentrEnumrr%r}rWrDrrr7r:Music21Exceptionr<ProtoM21Objectr@SlottedObjectMixinrlrzr|r _DOC_ORDERrmainTestr#rrrs6.##$  &{&&'>?  'tyy ' ( ( L#s4xT4d: < L11 J%7 ! !J%Z;!7 ! !6#<#<;!~ |<< ,\(\(~P ? tT *  zGr