jazzparser.formalisms.music_halfspan.semantics

1 """Semantics module for the music_halfspan formalism. 2 3 Lambda calculus semantics for the halfspan formalism. 4 This is the form of the semantics described in our paper appendix and in 5 my 2nd-year review. 6 7 """ 8 """ 9 ============================== License ======================================== 10 Copyright (C) 2008, 2010-12 University of Edinburgh, Mark Granroth-Wilding 11 12 This file is part of The Jazz Parser. 13 14 The Jazz Parser is free software: you can redistribute it and/or modify 15 it under the terms of the GNU General Public License as published by 16 the Free Software Foundation, either version 3 of the License, or 17 (at your option) any later version. 18 19 The Jazz Parser is distributed in the hope that it will be useful, 20 but WITHOUT ANY WARRANTY; without even the implied warranty of 21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 22 GNU General Public License for more details. 23 24 You should have received a copy of the GNU General Public License 25 along with The Jazz Parser. If not, see <http://www.gnu.org/licenses/>. 26 27 ============================ End license ====================================== 28 29 """ 30 __author__ = "Mark Granroth-Wilding <mark.granroth-wilding@ed.ac.uk>" 31 32 import copy, re, math 33 from ...base.semantics.lambdacalc import \ 34 Semantics as SemanticsBase, LambdaAbstraction as LambdaAbstractionBase, \ 35 FunctionApplication as FunctionApplicationBase, \ 36 Variable as VariableBase, Literal, LogicalForm, \ 37 DummyLogicalForm as DummyLogicalFormBase, \ 38 next_unused_variable, multi_apply as multi_apply_base, \ 39 multi_abstract as multi_abstract_base, Terminal 40 from ...base.semantics.temporal import Temporal, TemporalSemantics, \ 41 earliest_time 42 from jazzparser.utils.base import group_pairs 43 from jazzparser.utils.tonalspace import root_to_et_coord, \ 44 coordinate_to_roman_name, coordinate_to_et_2d, \ 45 coordinate_to_alpha_name_c 46 from jazzparser.settings import OPTIONS 47 from itertools import izip 48 49 # We set this here so that we don't have to look it up every time we output 50 # something. It's a little inelegant to hard-code it, but we can't get it 51 # from the Formalism now, because this needs to be imported to prepare the 52 # Formalism 53 # This is just for efficiency 54 FORMALISM_NAME = "music_halfspan"

55 56 -class Semantics(SemanticsBase, TemporalSemantics):

57 - def __init__(self, *args, **kwargs):

58 SemanticsBase.__init__(self, *args, **kwargs) 59 TemporalSemantics.__init__(self)

60

61 - def format_result(self):

62 return self.lf.format_result()

63

64 -class DummyLogicalForm(DummyLogicalFormBase, Temporal):

65 - def __init__(self, *args, **kwargs):

66 DummyLogicalFormBase.__init__(self, *args, **kwargs) 67 Temporal.__init__(self)

68

69 - def set_time(self, time):

70 self.time = time

71

72 - def get_literal_time_list(self):

73 return [self.time]

74

75 - def format_result(self):

76 return str(self)

77 78 79 INTERVAL_TO_NN = { 80 0 : (0,0), 81 1 : (-1,-1), 82 2 : (2,0), 83 3 : (1,-1), 84 4 : (0,1), 85 5 : (-1,0), 86 # We consistently make this arbitrary choice (not (2,1)) 87 6 : (-2,-1), 88 7 : (1,0), 89 8 : (0,-1), 90 9 : (-1,1), 91 10 : (-2,0), 92 11 : (1,1) 93 }

94 95 -class EnharmonicCoordinate(Terminal, Temporal):

96 """ 97 A four-dimensional coordinate. Stores the coordinate (x,y) within 98 an enharmonic (4x3) block, and the coordinate (X,Y) that locates 99 the enharmonic block within the infinite space. 100 101 Note that if x and y are set outside the range, they'll just be taken 102 mod 4 and 3 respectively. If you want to set x,y and X,Y from a 2D 103 coordinate, use from_harmonic_coord or the + operator. 104 105 This is used in the semantics as a tonic point. 106 107 """ 108 timed_object = True 109 delta = False 110

111 - def __init__(self, coord=(0,0), block=(0,0), time=None, duration=None, delta=False, *args, **kwargs):

112 """ 113 @type delta: bool 114 @param delta: whether this represents a vector, rather than a 115 point, in the tonal space. A delta coordinate will never show in 116 roman numeral format 117 118 """ 119 Terminal.__init__(self, *args, **kwargs) 120 Temporal.__init__(self, time=time, duration=duration) 121 122 self.delta = delta 123 self.x, self.y = coord 124 self.X, self.Y = block

125

126 - def __str__(self):

127 # Representation depends on the selected output format 128 fmt = OPTIONS.OUTPUT[FORMALISM_NAME]["tsformat"] 129 if self.delta or fmt == "xycoord": 130 # 2D coordinate 131 # Always use this format for deltas 132 return self.harmonic_str() 133 elif fmt == "roman": 134 # Roman numeral output 135 strng = "<%s>" % coordinate_to_roman_name(self.harmonic_coord) 136 elif fmt == "alpha": 137 # Note name output 138 strng = "<%s>" % coordinate_to_alpha_name_c(self.harmonic_coord) 139 else: 140 strng = "<(%d,%d)/(%d,%d)>" % (self.x, self.y, self.X, self.Y) 141 142 if self.time is not None: 143 strng = "%s@%d" % (strng,self.time) 144 return strng

145

146 - def format_result(self):

147 """ 148 When displaying LFs for results, the enharmonic block has no meaning 149 and is just confusing. Just show the (x,y) pair. 150 151 """ 152 return "<%d,%d>" % (self.x, self.y)

153

154 - def __repr__(self):

155 return str(self)

156

157 - def get_start_time(self):

158 return self.time

159

160 - def harmonic_str(self):

161 """ 162 A string representation of the coordinate that's like the normal 163 __str__, but displays the harmonic coordinate, rather than the 164 enharmonic 4-tuple. 165 166 """ 167 strng = "(%d,%d)" % self.harmonic_coord 168 if self.time is not None: 169 strng = "%s@%d" % (strng,self.time) 170 return strng

171

172 - def __eq__(self, other):

173 return type(self) == type(other) and \ 174 self.x == other.x and \ 175 self.y == other.y and \ 176 self.X == other.X and \ 177 self.Y == other.Y and \ 178 self.time == other.time

179

180 - def copy(self):

181 return EnharmonicCoordinate((self.x, self.y), (self.X, self.Y), 182 time=self._time, duration=self._duration, 183 delta=self.delta)

184

185 - def set_time(self, time):

186 self.time = earliest_time([time, self.time])

187 188 @property

189 - def zero_coord(self):

190 """ 191 Returns the 2D coordinate within an enharmonic block. 192 Equivalently, locates this coordinate in the zeroth enharmonic 193 block. 194 195 """ 196 return (self.x, self.y)

197 198 @property

199 - def block_coord(self):

200 """ 201 Returns the 2D location of the enharmonic block in which this 202 coordinate lies. 203 204 """ 205 return (self.X, self.Y)

206 207 @property

208 - def harmonic_coord(self):

209 """ 210 Returns the 2D coordinate (relative to the origin block) that 211 this enharmonic coordinate represents. 212 213 """ 214 return (4*self.X + self.x, 215 3*self.Y - self.X + self.y)

216 217 @staticmethod

218 - def from_harmonic_coord(coord):

219 """ 220 Creates an enharmonic coordinate from a harmonic coordinate, 221 given as a 2-tuple. 222 223 """ 224 # Check this is a 2-tuple 225 x,y = coord 226 encoord = EnharmonicCoordinate() 227 # add_coord has all the arithmetic we need 228 encoord += (x,y) 229 return encoord

230

231 - def _get_x(self):

232 return self._x

233 - def _set_x(self, x):

234 self._x = x % 4

235 x = property(_get_x, _set_x) 236

237 - def _get_y(self):

238 return self._y

239 - def _set_y(self, y):

240 self._y = y % 3

241 y = property(_get_y, _set_y) 242

243 - def _get_X(self):

244 return self._X

245 - def _set_X(self, X):

246 self._X = X

247 X = property(_get_X, _set_X) 248

249 - def _get_Y(self):

250 return self._Y

251 - def _set_Y(self, Y):

252 self._Y = Y

253 Y = property(_get_Y, _set_Y) 254

255 - def nearest(self, coord):

256 """ 257 Given a 2D coord within an enharmonic block, returns an 258 L{EnharmonicCoordinate} for the instance of that point that is 259 closest to this enharmonic coordinate. 260 261 @type coord: 2-tuple or L{EnharmonicCoordinate} 262 @param coord: if given as a tuple, should be a coordinate within 263 a block (i.e. between (0,0) and (4,3)); if an EC, the EC's zero 264 coord will be used 265 266 """ 267 if type(coord) == EnharmonicCoordinate: 268 coord = coord.zero_coord 269 else: 270 assert 0 <= coord[0] <= 4 271 assert 0 <= coord[1] <= 3 272 273 base_x, base_y = self.harmonic_coord 274 # Get the ET pitch class note number of the base coord 275 base_note = 7*base_x + 4*base_y 276 # Do the same for the candidate coordinate 277 candidate_note = 7*coord[0] + 4*coord[1] 278 # Decide which nearby point to pick, relative to the base, by 279 # looking at the interval 280 interval = (candidate_note - base_note) % 12 281 # Now we just consult the predefined mapping of intervals to nearest 282 # neighbours: 283 # 9 4 11 6 284 # 10 5 0 7 2 285 # 1 8 3 286 rel_coord = INTERVAL_TO_NN[interval] 287 # Now add this to the base coord to get the actual coord of the neighbour 288 return EnharmonicCoordinate.from_harmonic_coord( 289 (base_x+rel_coord[0], base_y+rel_coord[1]))

290

291 - def add_coord(self, coord=(0,0), delta=False):

292 """ 293 Returns an enharmonic coordinate that results from adding the 294 2D harmonic coordinates to this enharmonic coordinate. 295 296 E.g. 297 <(0,1)/(0,0)> + (-1,0) = <(3,0)/(-1,0)> 298 and 299 <(1,0)/(0,0)> + (-1,0) = <(0,0)/(0,0)> 300 301 """ 302 absx = self.x + coord[0] 303 absy = self.y + coord[1] 304 # Work out what block we're in, relative to where we started 305 blockshiftx = (absx / 4) 306 blockshifty = (absy + blockshiftx) / 3 307 # x coords just wrap around every 4 308 newx = absx % 4 309 # y coords wrap around at a position that depends on how much 310 # we're moving in x 311 newy = (absy+blockshiftx) % 3 312 313 newX = self.X + blockshiftx 314 newY = self.Y + blockshifty 315 return EnharmonicCoordinate((newx, newy), (newX, newY), delta=delta)

316

317 - def __add__(self, other):

318 """ 319 Define addition for 2D coordinates (same as L{add_coord}) 320 and C{EnharmonicCoordinate}s. 321 322 """ 323 if type(other) == tuple: 324 if len(other) == 2: 325 return self.add_coord(other) 326 else: 327 raise TypeError, "tuples added to an "\ 328 "EnharmonicCoordinate must be 2-tuples (got %d)" % len(other) 329 elif type(other) == EnharmonicCoordinate: 330 # Just convert the encoord into a 2D harmonic coord and add that 331 # to ourselves 332 delta = self.delta and other.delta 333 # If both inputs are deltas, the output should be 334 # Otherwise, the output is never a delta 335 # We don't complain if neither input is a delta, though we probably should 336 return self.add_coord(other.harmonic_coord, delta=delta) 337 else: 338 raise TypeError, "cannot add object of type %s to an "\ 339 "EnharmonicCoordinate" % type(other).__name__

340

341 - def __sub__(self, other):

342 """ 343 Define subtraction for 2D coordinates and C{EnharmonicCoordinate}s. 344 345 Result is always a delta. 346 347 """ 348 if type(other) == tuple: 349 if len(other) == 2: 350 return self.add_coord((-other[0],-other[1]), delta=True) 351 else: 352 raise TypeError, "tuples subtracted from an "\ 353 "EnharmonicCoordinate must be 2-tuples (got %d)" % len(other) 354 elif type(other) == EnharmonicCoordinate: 355 # Just convert the encoord into a 2D harmonic coord and subtract 356 # that from ourselves 357 hc = other.harmonic_coord 358 return self.add_coord((-hc[0], -hc[1]), delta=True) 359 else: 360 raise TypeError, "cannot add object of type %s to an "\ 361 "EnharmonicCoordinate" % type(other).__name__

362

363 -class LexicalCoordinate(Terminal, Temporal):

364 """ 365 When a logical form is read in from the lexicon, coordinates 366 must be specified relative to the root of the chord. Only when the 367 sign is used as the interpretation of a chord will this root 368 be known. In the meantime, we store a coordinate 369 (0,0) <= (cx,cy) <= (4,3) that specifies the position of the point 370 relative to the (equal temperament) position (x,y) of the chord 371 root. 372 Once this is known, an L{EnharmonicCoordinate} will be produced 373 at ((x+cx)%4, (y+cy)%3). 374 375 """ 376 timed_object = True 377

378 - def __init__(self, coord=(0,0), time=None, duration=None, *args, **kwargs):

379 Terminal.__init__(self, *args, **kwargs) 380 Temporal.__init__(self, time=time, duration=duration) 381 self.x, self.y = coord

382

383 - def __str__(self):

384 return "X(%d,%d)" % (self.x, self.y)

385

386 - def format_result(self):

387 return str(self)

388

389 - def get_start_time(self):

390 return self.time

391

392 - def harmonic_str(self):

393 """ 394 Same as __str__. Only here for compatibility with EnharmonicCoordinate. 395 396 """ 397 return str(self)

398

399 - def __eq__(self, other):

400 return type(self) == type(other) and \ 401 self.x == other.x and self.y == other.y

402

403 - def set_time(self, time):

404 self.time = earliest_time([time, self.time])

405

406 - def resolve(self, coord=(0,0)):

407 """ 408 Produces the actual L{EnharmonicCoordinate}, given the 2D 409 position of the chord root. 410 411 """ 412 return EnharmonicCoordinate( 413 ((self.x+coord[0])%4, (self.y+coord[1])%3))

414

415 - def copy(self):

416 return LexicalCoordinate((self.x, self.y), 417 time=self.time, duration=self.duration)

418

419 -class GhostCoordinate(Terminal, Temporal):

420 """ 421 Wrapper that stores an L{EnharmonicCoordinate}. The idea of this is 422 that it can be used in getting a path from coordinations to represent 423 the resolution of a cadence, but without the coordinate itself 424 featuring in the path. It just signals that things should be taken relative 425 to this point, but that the point itself should be burnt after reading. 426 427 """

428 - def __init__(self, coordinate, *args, **kwargs):

429 Terminal.__init__(self, *args, **kwargs) 430 Temporal.__init__(self) 431 432 self.coordinate = coordinate

433

434 - def get_start_time(self):

435 return self.time

436

437 - def __str__(self):

438 return "~%s~" % self.coordinate

439

440 - def format_result(self):

441 return str(self)

442

443 - def __eq__(self, other):

444 return type(self) == type(other) and \ 445 self.coordinate == other.coordinate

446

447 - def copy(self):

448 return GhostCoordinate(self.coordinate.copy())

449

450 -class List(LogicalForm, Temporal):

451 """ 452 The I{Path} or I{List} data structure. Primarily this is a list of 453 enharmonic coordinates or logical forms. In the written semantics, this 454 is shown as a list, but it is subject to certain reductions, such as when 455 a predicate (like I{leftonto}) is applied to it. 456 457 The items are implemented simply as a Python list, which should 458 make list processing much more efficient than if we used a 459 linked list implementation that corresponds better to the 460 theoretical definition of the semantics. 461 462 """

463 - def __init__(self, items=[], *args, **kwargs):

464 LogicalForm.__init__(self, *args, **kwargs) 465 Temporal.__init__(self) 466 467 self._items = [] 468 self.extend(items)

469

470 - def __str__(self):

471 return "[%s]" % ", ".join(str(child) for child in self)

472

473 - def format_result(self):

474 return "[%s]" % ", ".join(child.format_result() for child in self)

475

476 - def __eq__(self, other):

477 return type(self) == type(other) and \ 478 all(this==that for (this,that) in zip(self,other))

479

480 - def get_start_time(self):

481 if len(self) > 0: 482 return self[0].get_start_time() 483 else: 484 # This should never happen in practice 485 return None

486

487 - def set_time(self, time):

488 if len(self) > 0: 489 self[0].set_time(time)

490

491 - def append(self, point):

492 """ 493 Appends the point to the path. 494 495 """ 496 self._items.append(point) 497 point.parent = self

498

499 - def prepend(self, point):

500 """ 501 Prepends the point to the start of the path. 502 503 Same as L{insert}(0, point). 504 505 """ 506 self.insert(0, point)

507

508 - def extend(self, points):

509 """ 510 Appends all points in the given list to the points of the path. 511 512 """ 513 self._items.extend(points) 514 for p in points: 515 p.parent = self

516

517 - def __len__(self):

518 return len(self._items)

519

520 - def __getitem__(self, i):

521 return self._items[i]

522 - def __setitem__(self, i, val):

523 self._items[i] = val 524 val.parent = self

525

526 - def pop(self, i):

527 """Removes and returns the ith point from the path""" 528 child = self._items.pop(i) 529 # Orphan the child 530 child.parent = None 531 return child

532

533 - def insert(self, i, point):

534 """Inserts a point at the given position on the path""" 535 self._items.insert(i, point) 536 point.parent = self

537

538 - def shift_block(self, shift):

539 """ 540 Moves all the points on the path to another block, given relative to 541 their old one C{shift}. 542 543 @type shift: 2-tuple of ints 544 @param shift: block shift to apply to each point on the path. 545 546 """ 547 raise NotImplementedError, "I haven't got round to doing this yet"

548

549 - def copy(self):

550 items = [p.copy() for p in self] 551 return List(items=items)

552

553 - def to_list(self):

554 """ 555 Implemented for backward-compatibility with older formalisms. Just 556 returns list(path). 557 """ 558 return list(self)

559 560 ######## LogicalForm abstract methods

561 - def alpha_convert(self, src, trg):

562 for child in self.get_children(): 563 child.alpha_convert(src, trg)

564

565 - def beta_reduce(self, *args, **kwargs):

566 for child in self.get_children(): 567 child.beta_reduce() 568 return self

569

570 - def substitute(self, src, trg):

571 for child in self.get_children(): 572 child.substitute(src, trg)

573

574 - def replace_immediate_constituent(self, old_lf, new_lf):

575 # Check for the constituent in each position on the path 576 for i,point in enumerate(self): 577 if point is old_lf: 578 self.pop(i) 579 self.insert(i, new_lf)

580

581 - def get_variables(self):

582 return list(set(sum([p.get_variables() for p in self.get_children()], [])))

583

584 - def get_bound_variables(self):

585 return list(set(sum([p.get_bound_variables() for p in self.get_children()], [])))

586

587 - def get_children(self):

588 return list(self)

589

590 - def alpha_equivalent(self, other, substitution):

591 if type(self) != type(other): 592 return False 593 if len(self) != len(other): 594 return False 595 # Using izip here means we don't have to produce the whole list if 596 # something in it fails to match 597 for our_child,its_child in izip(self, other): 598 if not our_child.alpha_equivalent(its_child, substitution): 599 return False 600 return True

601

602 -class ListCat(LogicalForm, Temporal):

603 """ 604 Represents the concatenation of multiple L{List}s. As soon as all of the 605 elements beta-reduce to L{List}s, this will beta-reduce to a list as 606 well. This allows you to concatenate things that will be lists, but 607 aren't yet. 608 609 """

610 - def __init__(self, lists=[], *args, **kwargs):

611 LogicalForm.__init__(self, *args, **kwargs) 612 Temporal.__init__(self) 613 self.lists = lists 614 615 for lst in lists: 616 lst.parent = self

617

618 - def __str__(self):

619 return "+".join([str(l) for l in self.lists])

620

621 - def format_result(self):

622 # This should appear in results 623 return "+".join([l.format_result() for l in self.lists])

624

625 - def __eq__(self, other):

626 return type(self) == type(other) and \ 627 self.lists == other.lists

628

629 - def __len__(self):

630 return len(self.lists)

631

632 - def get_start_time(self):

633 if len(self.lists) > 0: 634 return self.lists[0].get_start_time() 635 else: 636 return []

637

638 - def set_time(self, time):

639 if len(self.lists) > 0: 640 self.lists[0].set_time(time)

641

642 - def copy(self):

643 lists = [l.copy() for l in self.lists] 644 return ListCat(lists=lists)

645 646 ######## LogicalForm abstract methods

647 - def alpha_convert(self, src, trg):

648 for child in self.get_children(): 649 child.alpha_convert(src, trg)

650

651 - def beta_reduce(self, *args, **kwargs):

652 # Reduce all children first 653 for child in self.get_children(): 654 child.beta_reduce() 655 # See whether all the children are lists now 656 if all(isinstance(l, List) for l in self.lists): 657 # We're ready to do the concatenation 658 biglist = self.lists[0] 659 for latter in self.lists[1:]: 660 biglist.extend(latter) 661 # Now replace ourselves with this path 662 self.replace_in_parent(biglist) 663 return biglist 664 else: 665 return self

666

667 - def substitute(self, src, trg):

668 for child in self.get_children(): 669 child.substitute(src, trg)

670

671 - def replace_immediate_constituent(self, old_lf, new_lf):

672 # Check for the constituent in each of our paths 673 for i,lst in enumerate(self.lists): 674 if lst is old_lf: 675 old_lf.parent = None 676 self.lists.pop(i) 677 self.lists.insert(i, new_lf) 678 new_lf.parent = self

679

680 - def get_variables(self):

681 return list(set(sum([p.get_variables() for p in self.get_children()], [])))

682

683 - def get_bound_variables(self):

684 return list(set(sum([p.get_bound_variables() for p in self.get_children()], [])))

685

686 - def get_children(self):

687 return [p for p in self.lists]

688

689 - def alpha_equivalent(self, other, substitution):

690 if type(self) != type(other): 691 return False 692 if len(self.lists) != len(other.lists): 693 return False 694 for our_child,its_child in zip(self.lists, other.lists): 695 if not our_child.alpha_equivalent(its_child, substitution): 696 return False 697 return True

698 ########

699 700 -class Coordination(LogicalForm, Temporal):

701 """ 702 Special operator to represent coordination. Beta reduction collapses 703 nested coordinations into one. 704 705 """

706 - def __init__(self, cadences=[], *args, **kwargs):

707 LogicalForm.__init__(self, *args, **kwargs) 708 Temporal.__init__(self) 709 710 self._cadences = [] 711 self.extend(cadences)

712

713 - def __str__(self):

714 return "(%s)" % " & ".join([str(c) for c in self._cadences])

715

716 - def format_result(self):

717 return "(%s)" % " & ".join([c.format_result() for c in self._cadences])

718

719 - def __eq__(self, other):

720 return type(self) == type(other) and \ 721 all(this==that for (this,that) in zip(self,other))

722

723 - def __len__(self):

724 return len(self._cadences)

725 - def __getitem__(self, i):

726 return self._cadences[i]

727 - def __setitem__(self, i, val):

728 self._cadences[i] = val 729 val.parent = self

730

731 - def get_start_time(self):

732 if len(self): 733 return self[0].get_start_time() 734 else: 735 return None

736

737 - def append(self, cad):

738 self._cadences.append(cad) 739 cad.parent = self

740

741 - def extend(self, other):

742 for cad in other: 743 self.append(cad)

744

745 - def insert(self, i, item):

746 self._cadences.insert(i, item) 747 item.parent = self

748

749 - def set_time(self, time):

750 if len(self): 751 self[0].set_time(time)

752

753 - def copy(self):

754 cads = [c.copy() for c in self] 755 return Coordination(cads)

756 757 ######## LogicalForm abstract methods

758 - def alpha_convert(self, src, trg):

759 for child in self.get_children(): 760 child.alpha_convert(src, trg)

761

762 - def beta_reduce(self, *args, **kwargs):

763 # Reduce all children first 764 for child in self.get_children(): 765 child.beta_reduce() 766 # Look for coordinations as children and flatten them 767 coords = [(i,c) for (i,c) in enumerate(self) if isinstance(c, Coordination)] 768 shift = 0 769 for i,coord in coords: 770 # Remove the coordination from our children 771 self._cadences.pop(i+shift) 772 shift -= 1 773 # Add its children instead 774 for child in coord: 775 self.insert(i+shift+1, child) 776 shift += 1 777 # Disown the original child 778 coord.parent = None 779 return self

780

781 - def substitute(self, src, trg):

782 for child in self.get_children(): 783 child.substitute(src, trg)

784

785 - def replace_immediate_constituent(self, old_lf, new_lf):

786 # Check for the constituent in each of our paths 787 for i,lst in enumerate(self): 788 if lst is old_lf: 789 old_lf.parent = None 790 self._cadences.pop(i) 791 self._cadences.insert(i, new_lf) 792 new_lf.parent = self

793

794 - def get_variables(self):

795 return list(set(sum([c.get_variables() for c in self.get_children()], [])))

796

797 - def get_bound_variables(self):

798 return list(set(sum([c.get_bound_variables() for c in self.get_children()], [])))

799

800 - def get_children(self):

801 return list(self)

802

803 - def alpha_equivalent(self, other, substitution):

804 if type(self) != type(other): 805 return False 806 if len(self) != len(other): 807 return False 808 for our_child,its_child in zip(self, other): 809 if not our_child.alpha_equivalent(its_child, substitution): 810 return False 811 return True

812 ######## 813

814 - def _function_apply(self, argument):

815 """ 816 Just as with predicates, reduce when this is applied to a list. 817 818 """ 819 if isinstance(argument, List): 820 argument[0] = FunctionApplication(self, argument[0]) 821 return argument 822 else: 823 # Do nothing special with the predicate 824 return None

825

826 -class Variable(VariableBase, Temporal):

827 """ 828 Standard variable implementation overridden to add time 829 processing. 830 831 """

832 - def __init__(self, *args, **kwargs):

833 VariableBase.__init__(self, *args, **kwargs) 834 Temporal.__init__(self)

835

836 - def set_time(self, time):

837 pass

838

839 - def get_start_time(self):

840 return None

841

842 - def copy(self):

843 return Variable(self.name, self.index)

844

845 - def format_result(self):

846 return str(self)

847

848 -class LambdaAbstraction(LambdaAbstractionBase, Temporal):

849 """ 850 Standard abstraction implementation overridden to add time 851 processing. 852 853 """ 854 VARIABLE_CLASS = Variable 855

856 - def __init__(self, *args, **kwargs):

857 LambdaAbstractionBase.__init__(self, *args, **kwargs) 858 Temporal.__init__(self)

859

860 - def set_time(self, time):

861 self.expression.set_time(time)

862

863 - def get_start_time(self):

864 return self.expression.get_start_time()

865

866 - def result_comma_string(self):

867 var = self.variable.format_result() 868 ## If the sub-expression is another abstraction, use comma notation for that 869 if type(self.expression) == type(self): 870 return "%s,%s" % (var, self.expression.result_comma_string()) 871 else: 872 return "%s.%s" % (var, self.expression.format_result())

873

874 - def format_result(self):

875 return "\\%s" % self.result_comma_string()

876

877 -class FunctionApplication(FunctionApplicationBase, Temporal):

878 """ 879 Standard application implementation overridden to add time 880 processing. 881 882 """

883 - def set_time(self, time):

884 self.functor.set_time(time)

885

886 - def __str__(self):

887 """ 888 Special str to make predicates appear in FOL style, rather than HOL 889 style, which is the default. 890 891 """ 892 if isinstance(self.functor, Predicate): 893 return "%s(%s)" % (self.functor.predicate_str(), self.argument) 894 else: 895 return FunctionApplicationBase.__str__(self)

896

897 - def format_result(self):

898 if isinstance(self.functor, Predicate): 899 return "%s(%s)" % (self.functor.predicate_str(), 900 self.argument.format_result()) 901 else: 902 return self._format(lambda x:x.format_result())

903

904 - def get_start_time(self):

905 return self.functor.get_start_time()

906

907 -class Predicate(Literal, Temporal):

908 """ 909 Superclass of literal predicates (such as leftonto). 910 911 """ 912 timed_object = True 913

914 - def __init__(self, *args, **kwargs):

915 time = kwargs.pop("time", None) 916 duration = kwargs.pop("duration", None) 917 Literal.__init__(self, *args, **kwargs) 918 Temporal.__init__(self, time=time, duration=duration)

919

920 - def __eq__(self, other):

921 return type(self) == type(other) and \ 922 self.time == other.time

923

924 - def __str__(self):

925 base = super(Predicate, self).__str__() 926 if self.time is not None: 927 return "%s@%d" % (base, self.time) 928 else: 929 return base

930

931 - def predicate_str(self):

932 """ 933 Returns a string that should be used as the str representation of 934 this predicate when it's used in a function application: 935 e.g. leftonto(...) 936 937 """ 938 if self.time is not None and OPTIONS.OUTPUT_ALL_TIMES: 939 return "%s@%d" % (self.name, self.time) 940 else: 941 return self.name

942

943 - def format_result(self):

944 # This shouldn't get called in practice 945 return str(self)

946

947 - def _function_apply(self, argument):

948 """ 949 Implements the special behaviours of predicates when applied to 950 lists. 951 952 """ 953 if isinstance(argument, List): 954 argument[0] = FunctionApplication(self, argument[0]) 955 return argument 956 else: 957 # Do nothing special with the predicate 958 return None

959

960 - def copy(self):

961 return type(self)(time=self.time, duration=self.duration)

962

963 - def set_time(self, time):

964 self.time = earliest_time([time, self.time])

965

966 - def get_start_time(self):

967 return self.time

968

969 -class Leftonto(Predicate):

970 """ 971 A leftonto predicate literal. Apply leftonto to a path using 972 a function application: 973 (leftonto ...) 974 975 """

976 - def __init__(self, *args, **kwargs):

977 Predicate.__init__(self, "leftonto", *args, **kwargs)

978

979 -class Rightonto(Predicate):

980 """ 981 A rightonto predicate literal, analagous to L{Leftonto}. 982 983 """

984 - def __init__(self, *args, **kwargs):

985 Predicate.__init__(self, "rightonto", *args, **kwargs)

986

987 -class Now(Predicate):

988 """ 989 A special predicate that doesn't change its argument at all, except to 990 set its start time to be no later than the start time associated with the 991 predicate. 992 993 """

994 - def __init__(self, *args, **kwargs):

995 Predicate.__init__(self, "now", *args, **kwargs)

996

997 - def predicate_str(self):

998 """ 999 Returns a string that should be used as the str representation of 1000 this predicate when it's used in a function application: 1001 e.g. leftonto(...) 1002 1003 """ 1004 if self.time is not None: 1005 return "%s@%d" % (self.name, self.time)

1006

1007 - def _function_apply(self, argument):

1008 """ 1009 Override function application behaviour. 1010 1011 If we're applied to a coordinate or a predicate application, we give 1012 them our time and burn after reading. 1013 1014 """ 1015 # First apply the general predicate behaviour 1016 modified = super(Now, self)._function_apply(argument) 1017 if modified is not None: 1018 # The parent's reduction transplanted this predicate 1019 # Return this for now. It'll get beta-reduced again before being 1020 # considered beta-normal and we'll deal with any further 1021 # behaviour then 1022 return modified 1023 1024 if isinstance(argument, EnharmonicCoordinate): 1025 # Set the time on the coordinate and return it 1026 argument.set_time(self.time) 1027 elif isinstance(argument, FunctionApplication) and \ 1028 isinstance(argument.functor, (Leftonto,Rightonto,Coordination,Now)): 1029 # These are functors that will never be reduced any further 1030 # Set the time on the predicate and return the application 1031 # This includes eliminating recursive Nows, which should take the 1032 # the outermost time 1033 argument.functor.set_time(self.time) 1034 elif isinstance(argument, Coordination): 1035 # Set the time of the first constituent cadence and disappear 1036 argument[0].set_time(self.time) 1037 else: 1038 return None 1039 return argument

1040

1041 1042 ############# Special logical forms for representing paths directly ######### 1043 # These should not be used in the parsers anywhere. They're here mainly 1044 # for the backoff models, which need to produce a LF to store as a result 1045 1046 -class PathCoordinate(EnharmonicCoordinate):

1047 """ 1048 Simple subclass of EnharmonicCoordinate to store points on a path directly. 1049 Doesn't provide all of the fancy coordinate manipulation stuff provided 1050 by EC: use EC itself for that. 1051 1052 This is a special 1053 kind of semantics for storing results from backoff models. 1054 1055 """

1056 - def __init__(self, *args, **kwargs):

1057 self.function = kwargs.pop('function', 'T') 1058 super(PathCoordinate, self).__init__(*args, **kwargs)

1059

1060 - def format_result(self):

1061 """ In this case, we output the full harmonic coordinate """ 1062 return self.harmonic_str()

1063

1064 - def copy(self):

1065 return PathCoordinate((self.x, self.y), (self.X, self.Y), 1066 time=self._time, duration=self._duration, 1067 delta=self.delta, function=self.function)

1068

1069 - def __eq__(self, other):

1070 return super(EnharmonicCoordinate, self).__eq__(other) and \ 1071 self.function == other.function

1072

1073 - def to_enharmonic_coord(self):

1074 return EnharmonicCoordinate((self.x, self.y), (self.X, self.Y), 1075 time=self._time, duration=self._duration, 1076 delta=self.delta)

1077 1078 @staticmethod

1079 - def from_enharmonic_coord(ec):

1080 return PathCoordinate((ec.x, ec.y), (ec.X, ec.Y), 1081 time=ec._time, duration=ec._duration, 1082 delta=ec.delta)

1083

1084 -class CoordinateList(LogicalForm, Temporal):

1085 """ 1086 Just a list of enharmonic coordinates, forming a tonal space path. 1087 Should not be used as part of the regular semantics. This is a special 1088 kind of semantics for storing results from backoff models. 1089 1090 """

1091 - def __init__(self, items=[], *args, **kwargs):

1092 LogicalForm.__init__(self, *args, **kwargs) 1093 Temporal.__init__(self) 1094 self._items = [] 1095 self.extend(items)

1096

1097 - def __str__(self):

1098 return "[%s]" % ", ".join(str(child) for child in self)

1099

1100 - def format_result(self):

1101 return "[%s]" % ", ".join(child.format_result() for child in self)

1102

1103 - def __eq__(self, other):

1104 return type(self) == type(other) and \ 1105 all(this==that for (this,that) in zip(self,other))

1106

1107 - def set_time(self, time):

1108 if len(self) > 0: 1109 self[0].set_time(time)

1110

1111 - def append(self, point):

1112 """ 1113 Appends the point to the path. 1114 1115 """ 1116 if type(point) != PathCoordinate: 1117 raise TypeError, "CoordinateList can only store PathCoordinates" 1118 self._items.append(point) 1119 point.parent = self

1120

1121 - def extend(self, points):

1122 """ 1123 Appends all points in the given list to the points of the path. 1124 1125 """ 1126 if not all(type(p) == PathCoordinate for p in points): 1127 raise TypeError, "CoordinateList can only store PathCoordinates" 1128 self._items.extend(points) 1129 for p in points: 1130 p.parent = self

1131

1132 - def __len__(self):

1133 return len(self._items)

1134

1135 - def __getitem__(self, i):

1136 return self._items[i]

1137 - def __setitem__(self, i, val):

1138 if type(val) != PathCoordinate: 1139 raise TypeError, "CoordinateList can only store PathCoordinates" 1140 self._items[i] = val 1141 val.parent = self

1142

1143 - def copy(self):

1144 items = [p.copy() for p in self] 1145 return CoordinateList(items=items)

1146

1147 - def alpha_convert(self, src, trg):

1148 # No variables allowed 1149 return

1150

1151 - def beta_reduce(self, *args, **kwargs):

1152 # Always in BNF 1153 return self

1154

1155 - def substitute(self, src, trg):

1156 # No variables allowed 1157 return

1158

1159 - def replace_immediate_constituent(self, old_lf, new_lf):

1160 # Check for the constituent in each position on the path 1161 for i,point in enumerate(self): 1162 if point is old_lf: 1163 old = self._items.pop(i) 1164 old.parent = None 1165 self._items.insert(i, new_lf) 1166 new_lf.parent = self

1167

1168 - def get_variables(self):

1169 return []

1170

1171 - def get_bound_variables(self):

1172 return []

1173

1174 - def get_children(self):

1175 return list(self)

1176

1177 - def alpha_equivalent(self, other, substitution):

1178 # No variables allowed, so only a-equiv if equal 1179 return self == other

1180

1181 ################# Shortcut functions ############################## 1182 -def apply(fn, arg, grammar=None):

1183 """ 1184 Applies fn to arg by creating a FunctionApplication and returns the 1185 result. This is used for formalism-unspecific access to this feature. 1186 1187 """ 1188 new_sem = Semantics(FunctionApplication(fn.lf, arg.lf)) 1189 new_sem.beta_reduce() 1190 return new_sem

1191

1192 -def compose(f, g, grammar=None):

1193 """ 1194 Performs logical composition in this semantic formalism. 1195 1196 """ 1197 f_vars = set(f.lf.get_variables()) 1198 g_vars = set(g.lf.get_variables()) 1199 used_vars = f_vars | g_vars 1200 # Get a variable that isn't found in either function 1201 var = Variable("x") 1202 var = next_unused_variable(var, used_vars) 1203 new_sem = Semantics( 1204 LambdaAbstraction(\ 1205 var, 1206 FunctionApplication(\ 1207 f.lf, 1208 FunctionApplication(\ 1209 g.lf, 1210 var 1211 ) 1212 ) 1213 ) 1214 ) 1215 new_sem.beta_reduce() 1216 return new_sem

1217

1218 -def multi_apply(*args):

1219 return multi_apply_base(FunctionApplication, *args)

1220

1221 -def multi_abstract(*args):

1222 return multi_abstract_base(LambdaAbstraction, *args)

1223

1224 -def concatenate(lst1, lst2):

1225 """ 1226 Returns the concatenation of the two lists. 1227 Uses existing instances passed in, so make sure they're copies 1228 if you don't want your original objects modified. 1229 1230 """ 1231 cat = Semantics(ListCat([lst1.lf, lst2.lf])) 1232 cat.beta_reduce() 1233 return cat

1234

1235 ################ Utilities ############# 1236 -def make_absolute_lf_from_relative(sems, root_coord):

1237 if isinstance(sems, Semantics): 1238 make_absolute_lf_from_relative(sems.lf, root_coord) 1239 elif isinstance(sems, LexicalCoordinate): 1240 # This is the only thing that actually changes 1241 # Replace all lexical coordinates with actual coordinates, 1242 # now we know what they're relative to 1243 abs_coord = sems.resolve(root_coord) 1244 sems.replace_in_parent(abs_coord) 1245 else: 1246 # Otherwise just recurse to children 1247 children = [c for c in sems.get_children()] 1248 for child in children: 1249 make_absolute_lf_from_relative(child, root_coord)

1250

1251 -def list_lf_to_coordinates(lst, start_block=(0,0)):

1252 """ 1253 Produces a list of (x,y) coordinates in the tonal space, given 1254 a L{List} or L{CoordinateList}. 1255 1256 @type lst: L{List} 1257 @param lst: list from the semantics representing constraints on a TS path 1258 @type start_block: pair of ints 1259 @param start_block: enharmonic block to start in (if other than 1260 the default (0,0)) 1261 @return: 2D coordinates of the path through the tonal space and the 1262 times at which they were reached. 1263 1264 """ 1265 if isinstance(lst, CoordinateList): 1266 path = [p.harmonic_coord for p in lst] 1267 times = [p.time for p in lst] 1268 return zip(path, times) 1269 1270 def _remove_nows(el): 1271 if isinstance(el, FunctionApplication) and isinstance(el.functor, Now): 1272 # Remove this: recurse to argument 1273 return _remove_nows(el.argument) 1274 else: 1275 for child in el.get_children(): 1276 el.replace_immediate_constituent(child, _remove_nows(child)) 1277 return el

1278 1279 def _to_coords(el): 1280 if isinstance(el, EnharmonicCoordinate): 1281 # Coordinate just becomes a single-element path 1282 return [(EnharmonicCoordinate((el.x,el.y)), el.time)] 1283 elif isinstance(el, GhostCoordinate): 1284 # Treat the same as a coordinate at this stage 1285 return [(EnharmonicCoordinate((el.coordinate.x,el.coordinate.y)), el.coordinate.time)] 1286 elif isinstance(el, FunctionApplication): 1287 # If we're applying to a ghost, remove it once we're done 1288 remove_last = isinstance(el.argument, GhostCoordinate) 1289 # Recursively get a path for the argument 1290 argpath = _to_coords(el.argument) 1291 # Add something to the path depending on the functor 1292 if isinstance(el.functor, Leftonto): 1293 fullpath = [((argpath[0][0]+(1,0)), el.functor.time)] + argpath 1294 elif isinstance(el.functor, Rightonto): 1295 fullpath = [((argpath[0][0]+(-1,0)), el.functor.time)] + argpath 1296 elif isinstance(el.functor, Coordination): 1297 # Apply each coordinated cadence to the resolution 1298 resolution = Semantics(GhostCoordinate(argpath[0][0])) 1299 cadpaths = [] 1300 for cad in el.functor: 1301 # Apply the cadence to its resolution 1302 # This will beta-reduce 1303 cadsem = apply(Semantics(cad), resolution.copy()) 1304 cadpath = _to_coords(cadsem.lf) 1305 # String together the paths from each coordinated cadence 1306 cadpaths.extend(cadpath) 1307 # Follow up the cadences with their joint resolution 1308 fullpath = cadpaths + argpath 1309 else: 1310 raise SemanticsPostProcessError, "unknown functor %s" % \ 1311 el.functor 1312 1313 # Remove the ghost coordinate 1314 if remove_last: 1315 fullpath = fullpath[:-1] 1316 return fullpath 1317 elif isinstance(el, Coordination): 1318 raise SemanticsPostProcessError, "can't get a path for a "\ 1319 "coordination that's not applied to anything: %s" % el 1320 else: 1321 raise SemanticsPostProcessError, "don't know how to get a path "\ 1322 "for the lf %s" % el 1323 1324 start_point = None 1325 path = [] 1326 # Get a path for each element in the list 1327 for lf in lst: 1328 # There may be Now predicates in the lf 1329 # Remove them before continuing 1330 lf = _remove_nows(lf) 1331 1332 coords,times = zip(*_to_coords(lf)) 1333 # Shift this fragment to be as close as possible to the end of the previous 1334 if len(path) == 0: 1335 # Nothing on the path yet: start in the chosen start block 1336 new_block = start_block 1337 after_block = coords[0].block_coord 1338 else: 1339 # Translate the second path so that they make the nearest join possible 1340 before = path[-1][0].harmonic_coord 1341 before_block = path[-1][0].block_coord 1342 after = coords[0].harmonic_coord 1343 after_block = coords[0].block_coord 1344 1345 # Get the start point (2nd path) relative to the end point (1st path) 1346 diff = (after[0]-before[0], after[1]-before[1]) 1347 # Project this onto ET 1348 rel_pitch = coordinate_to_et_2d(diff) 1349 """ 1350 Each ET pitch has a closest instance to the start point: choose 1351 the one for this pitch. 1352 They're in a costellation around the base point (before) like this: 1353 VI III VII 1354 bVII IV I V II 1355 bV bII bVI bIII 1356 1357 """ 1358 rel_coord = { 1359 0 : (0,0), 1360 1 : (-1,-1), 1361 2 : (2,0), 1362 3 : (1,-1), 1363 4 : (0,1), 1364 5 : (-1,0), 1365 6 : (-2,-1), # This is an arbitrary choice: (2,1) is the same distance 1366 7 : (1,0), 1367 8 : (0,-1), 1368 9 : (-1,1), 1369 10 : (-2,0), 1370 11 : (1,1), 1371 }[rel_pitch] 1372 # Decide what coordinate the 2nd path should start on 1373 new_start = (before[0]+rel_coord[0], before[1]+rel_coord[1]) 1374 # Work out how many blocks we must shift the 2nd path by to do this 1375 new_start_coord = EnharmonicCoordinate.from_harmonic_coord(new_start) 1376 assert coords[0].zero_coord == new_start_coord.zero_coord 1377 new_block = new_start_coord.block_coord 1378 block_shift = (new_block[0]-after_block[0], new_block[1]-after_block[1]) 1379 1380 # Shift happens 1381 for coord in coords: 1382 coord.X += block_shift[0] 1383 coord.Y += block_shift[1] 1384 path.extend(zip(coords,times)) 1385 return [(coord.harmonic_coord, time) for (coord, time) in path] 1386

1387 -def list_lf_to_functions(lst):

1388 """ 1389 Like L{list_lf_to_coordinates}, but produces a list of (function,time) 1390 pairs instead of (coordinate,time). 1391 1392 @type lst: L{List} 1393 @param lst: list from the semantics representing constraints on a TS path 1394 @return: function strings of points on the path through the tonal space 1395 and the times at which they were reached. 1396 1397 """ 1398 if isinstance(lst, CoordinateList): 1399 funs = [p.function for p in lst] 1400 times = [p.time for p in lst] 1401 return zip(funs, times) 1402 1403 def _to_funs(el): 1404 if isinstance(el, EnharmonicCoordinate): 1405 # Coordinate just becomes a single-element path 1406 return [("T", EnharmonicCoordinate((el.x,el.y)), el.time)] 1407 elif isinstance(el, GhostCoordinate): 1408 # This should get removed, so don't put in a real function: we 1409 # want the error to be clear if it gets included 1410 return [("GHOST", 1411 EnharmonicCoordinate((el.coordinate.x,el.coordinate.y)), 1412 el.coordinate.time)] 1413 elif isinstance(el, FunctionApplication): 1414 # If we're applying to a ghost, remove it once we're done 1415 remove_last = isinstance(el.argument, GhostCoordinate) 1416 # Recursively get a function list for the argument 1417 argpath = _to_funs(el.argument) 1418 # Add something to the path depending on the functor 1419 if isinstance(el.functor, Leftonto): 1420 fullpath = [("D", (argpath[0][1]+(1,0)), el.functor.time)] + argpath 1421 elif isinstance(el.functor, Rightonto): 1422 fullpath = [("S", (argpath[0][1]+(-1,0)), el.functor.time)] + argpath 1423 elif isinstance(el.functor, Coordination): 1424 # Apply each coordinated cadence to the resolution 1425 resolution = Semantics(GhostCoordinate(argpath[0][1])) 1426 cadpaths = [] 1427 for cad in el.functor: 1428 # Apply the cadence to its resolution 1429 # This will beta-reduce 1430 cadsem = apply(Semantics(cad), resolution.copy()) 1431 cadpath = _to_funs(cadsem.lf) 1432 # String together the paths from each coordinated cadence 1433 cadpaths.extend(cadpath) 1434 # Add folow up the cadences with their joint resolution 1435 fullpath = cadpaths + argpath 1436 else: 1437 raise SemanticsPostProcessError, "unknown functor %s" % \ 1438 el.functor 1439 1440 # Remove the ghost coordinate 1441 if remove_last: 1442 fullpath = fullpath[:-1] 1443 return fullpath 1444 elif isinstance(el, Coordination): 1445 raise SemanticsPostProcessError, "can't get a path for a "\ 1446 "coordination that's not applied to anything: %s" % el 1447 else: 1448 raise SemanticsPostProcessError, "don't know how to get a path "\ 1449 "for the lf %s" % el

1450 1451 start_point = None 1452 path = [] 1453 # Get a path for each element in the list 1454 # When getting the coordinates we do shifting stuff here, but for functions 1455 # we can just concatenate 1456 path = sum((_to_funs(lf) for lf in lst), []) 1457 # Get rid of the coordinates 1458 funs,coords,times = zip(*path) 1459 path = zip(funs,times) 1460 return path 1461

1462 -def sign_to_coordinates(sign):

1463 return semantics_to_coordinates(sign.semantics)

1464

1465 -def semantics_to_coordinates(sems):

1466 """ 1467 Generates a list of (coordinates,time) tuples given a parse result. 1468 1469 @raise ValueError: if the result can't produce a list of coordinates. 1470 1471 """ 1472 if not isinstance(sems.lf, (List, CoordinateList)): 1473 # This result isn't a list, so we can't generate coordinates from it 1474 raise ValueError, "can't generate coordinates from a %s" % \ 1475 type(sems.lf).__name__ 1476 return list_lf_to_coordinates(sems.lf)

1477

1478 -def semantics_to_functions(sems):

1479 """ 1480 Generates a list of (function,time) tuples given a parse result. 1481 1482 @raise ValueError: if the result can't produce a list of coordinates. 1483 1484 """ 1485 if not isinstance(sems.lf, (List, CoordinateList)): 1486 # This result isn't a list, so we can't generate functions from it 1487 raise ValueError, "can't generate a function list from a %s" % \ 1488 type(sems.lf).__name__ 1489 return list_lf_to_functions(sems.lf)

1490

1491 1492 -def backoff_states_to_lf(states):

1493 """ 1494 Builds a logical form given a list of states and the 1495 chords they were assigned to. Accepts a list of labels,time 1496 and return a logical form for the formalism (a L{Semantics} in this 1497 case). 1498 1499 This uses the special logical form classes L{CoordinateList} and 1500 L{PathCoordinate}. 1501 1502 """ 1503 from jazzparser.data import Chord, Fraction 1504 1505 points = [] 1506 1507 # Special case for the first point 1508 ((first_point,first_fun), first_time) = states[0] 1509 first = PathCoordinate.from_enharmonic_coord( 1510 EnharmonicCoordinate((first_point[2],first_point[3]))) 1511 first.fun = first_fun 1512 first.time = first_time 1513 1514 points = [first] 1515 for ((point,fun),time) in states[1:]: 1516 # Reconstruct a path point from each label 1517 dX,dY,x,y = point 1518 # Get the nearest (x,y) to the previous point 1519 nearest = points[-1].nearest((x,y)) 1520 # Now shift it by the requested amount 1521 nearest.X += dX 1522 nearest.Y += dY 1523 1524 coord = PathCoordinate.from_enharmonic_coord(nearest) 1525 coord.function = fun 1526 coord.time = time 1527 points.append(coord) 1528 1529 if len(points): 1530 # Get rid of any points that just repeat the previous one 1531 previous = points[0] 1532 remove = [] 1533 for point in points[1:]: 1534 if point.harmonic_coord == previous.harmonic_coord and \ 1535 point.function == previous.function: 1536 remove.append(id(point)) 1537 previous = point 1538 points = [p for p in points if id(p) not in remove] 1539 1540 # Create a path out of these points 1541 path = CoordinateList(items=points) 1542 1543 return Semantics(path)

1544

1545 1546 -def semantics_to_keys(sems):

1547 """ 1548 Gets a list of keys implied by a logical form. 1549 1550 """ 1551 from jazzparser.utils.tonalspace import coordinate_to_et_2d 1552 1553 def _get_key(lf): 1554 if isinstance(lf, EnharmonicCoordinate): 1555 # TS point: return the key root 1556 return coordinate_to_et_2d(lf.zero_coord) 1557 elif isinstance(lf, FunctionApplication): 1558 # It so happens that every function application's key comes from 1559 # the right branch - its argument 1560 return _get_key(lf.argument) 1561 else: 1562 raise KeyInferenceError, "got unexpected LF in key inference: %s" \ 1563 % lf

1564 1565 # Recurse over the cadences 1566 keys = [] 1567 last_key = None 1568 for lf in sems.lf: 1569 # Work out the key of this cadence 1570 key = _get_key(lf) 1571 # Only include this key if it's changed since the last cadence 1572 if key != last_key: 1573 keys.append((key, lf.get_start_time())) 1574 last_key = key 1575 return keys 1576

1577 1578 -def semantics_from_string(string):

1579 """ 1580 Builds a L{Semantics} instance from a string representation of the logical 1581 form. This is mainly for testing and debugging and shouldn't be used in 1582 the wild (in the parser, for example). This is not how we construct 1583 logical forms out of the lexicon: they're specified in XML, which is a 1584 safer way to build LFs, though more laborious to write. 1585 1586 The strings may be constructed as follows. 1587 1588 B{Tonic semantics}: "<x,y>". This will build an L{EnharmonicCoordinate}. 1589 1590 B{List}: "[ITEM0, ITEM1, ...]". This will build a L{List}. 1591 1592 B{List concatenation}: "LIST0+LIST1", that is with infix notation. 1593 This will build a L{ListCat}. 1594 1595 B{Variable}: "$x0". Begin every variable with a $, as if you're writing PHP 1596 or Bash, or something. Use any variable name and, optionally, a number. 1597 If no number is given, 0 will be used by default. 1598 1599 B{Predicates} - leftonto, rightonto: "leftonto(...)", etc. Builds a 1600 L{FunctionApplication} with the predicate as its functor. 1601 1602 B{Now}: "now@x(...)". Works like the other predicates, but has the special 1603 "@x" value to give it a time. 1604 1605 B{Lambda abstraction}: "\\$x.EXPR". Use a backslash to represent a lambda. 1606 You can have multiple abstracted variables, which will result in multiple 1607 nested abstractions. EXPR can be any expression. 1608 1609 B{Function application}: "(FUNCTOR ARGUMENT)". Always enclose a function 1610 application in brackets, even if you wouldn't write them. 1611 1612 Note that the output is not beta-reduced. 1613 1614 """ 1615 def _find_matching(s, opener="[", closer="]"): 1616 opened = 0 1617 for i,char in enumerate(s): 1618 if char == closer: 1619 if opened == 0: 1620 return i 1621 else: 1622 opened -= 1 1623 elif char == opener: 1624 opened += 1 1625 # Matching brace not found 1626 raise SemanticsStringBuildError, "%s was not matched by a %s in %s" % \ 1627 (opener, closer, s)

1628 1629 # Recursive function to build the LF from a string 1630 def _build_lf(text): 1631 text = text.strip() 1632 if text.startswith("<"): 1633 # Enharmonic coordinate 1634 end = text.find(">") 1635 if end == -1: 1636 raise SemanticsStringBuildError, "unclosed enharmonic "\ 1637 "coordinate: %s" % text 1638 coord = text[1:end].split(",") 1639 if len(coord) != 2: 1640 raise SemanticsStringBuildError, "enharmonic coordinate must "\ 1641 "be a pair of values: %s" % text 1642 coord = int(coord[0]), int(coord[1]) 1643 lf = EnharmonicCoordinate.from_harmonic_coord(coord) 1644 leftover = text[end+1:] 1645 elif text.startswith("["): 1646 # List 1647 # Find where it ends 1648 end = _find_matching(text[1:]) + 1 1649 # Build each list item recursively 1650 remainder = text[1:end] 1651 items = [] 1652 # Keep processing each item until we've done them all 1653 while len(remainder): 1654 item, remainder = _build_lf(remainder) 1655 remainder = remainder.strip() 1656 if len(remainder): 1657 if not remainder.startswith(","): 1658 raise SemanticsStringBuildError, "could not parse %s in "\ 1659 "logical form %s" % (remainder, string) 1660 else: 1661 remainder = remainder[1:] 1662 items.append(item) 1663 lf = List(items=items) 1664 leftover = text[end+1:] 1665 elif text.startswith("$"): 1666 # Variable name 1667 # Ends at next non-alphanumeric character 1668 non_alph = re.compile(r'[^a-zA-Z0-9]') 1669 match = non_alph.search(text[1:]) 1670 if match is None: 1671 # or end of string 1672 end = len(text) 1673 else: 1674 end = match.start() + 1 1675 1676 # Split the number off the variable number 1677 var_splitter = re.compile(r'^(?P<name>.+?)(?P<number>\d*)$') 1678 match = var_splitter.match(text[1:end]) 1679 if match is None: 1680 raise SemanticsStringBuildError, "invalid variable name '%s'" % \ 1681 text[:end] 1682 matchgd = match.groupdict() 1683 var_name,var_num = matchgd['name'], matchgd['number'] 1684 if var_num == "": 1685 var_num = 0 1686 else: 1687 var_num = int(var_num) 1688 lf = Variable(var_name, var_num) 1689 leftover = text[end+1:] 1690 elif text.startswith("leftonto(") or text.startswith("rightonto(") or \ 1691 text.startswith("now@"): 1692 # Predicate 1693 if text.startswith("leftonto("): 1694 predicate = "leftonto" 1695 pred_obj = Leftonto() 1696 pred_len = len(predicate) 1697 elif text.startswith("rightonto("): 1698 predicate = "rightonto" 1699 pred_obj = Rightonto() 1700 pred_len = len(predicate) 1701 else: 1702 predicate = "now" 1703 pred_obj = Now() 1704 # Get the time value 1705 pred_len = text.find("(") 1706 time = int(text[4:pred_len]) 1707 pred_obj.time = time 1708 # Recursively process the argument of the predicate application 1709 # Find the closing bracket 1710 end = _find_matching(text[pred_len+1:], 1711 opener="(", closer=")") + pred_len + 1 1712 arg,rest = _build_lf(text[pred_len+1:end]) 1713 1714 # Check we used the whole 1715 if len(rest.strip()): 1716 raise SemanticsStringBuildError, "could not parse '%s' in "\ 1717 "argument to %s in '%s'" % (rest,predicate,string) 1718 1719 # Build the logical form 1720 lf = FunctionApplication( 1721 pred_obj, 1722 arg) 1723 leftover = text[end+1:] 1724 elif text.startswith("\\"): 1725 # Lambda abstraction 1726 # Look for a . that marks the end of the variable name 1727 dot = text.find(".") 1728 if dot == -1: 1729 raise SemanticsStringBuildError, "lambda abstraction needs a "\ 1730 "dot: %s (in %s)" % (text,string) 1731 # Build the LF for the variable(s) 1732 var_text = text[1:dot] 1733 variables = [] 1734 # Keep getting variables, separated by commas 1735 while len(var_text.strip()): 1736 var_text.lstrip(",") 1737 variable,var_text = _build_lf(var_text) 1738 if not isinstance(variable, Variable): 1739 raise SemanticsStringBuildError, "bad variable %s in "\ 1740 "lambda abstraction (%s)" % (variable,string) 1741 variables.append(variable) 1742 1743 # Continue to build the LF for the abstracted expression 1744 expr, leftover = _build_lf(text[dot+1:]) 1745 1746 args = variables + [expr] 1747 lf = multi_abstract(*args) 1748 elif text.startswith("("): 1749 # Function application or just brackets 1750 # Look for a matching bracket 1751 end = _find_matching(text[1:], opener="(", closer=")") + 1 1752 # Now parse the stuff between the brackets 1753 lf,rest = _build_lf(text[1:end]) 1754 # See whether there's a second expression 1755 if len(rest.strip()): 1756 # Must be a fun app 1757 second_lf,rest = _build_lf(rest) 1758 # There shouldn't be any more 1759 if len(rest.strip()): 1760 raise SemanticsStringBuildError, "don't know what to do "\ 1761 "with '%s' in '%s'" % (rest, string) 1762 lf = FunctionApplication(lf, second_lf) 1763 # Otherwise we just return the stuff between the brackets 1764 leftover = text[end+1:] 1765 else: 1766 raise SemanticsStringBuildError, "could not parse '%s' in '%s'" % \ 1767 (text,string) 1768 1769 # Check for infix operators 1770 leftover = leftover.strip() 1771 if leftover.startswith("+"): 1772 # List concatenation 1773 # Process the rest of the string 1774 second_lf, leftover = _build_lf(leftover[1:]) 1775 lf = ListCat([lf, second_lf]) 1776 elif leftover.startswith("&"): 1777 # Coordination 1778 second_lf, leftover = _build_lf(leftover[1:]) 1779 lf = Coordination([lf, second_lf]) 1780 1781 return lf, leftover 1782 1783 # Build a logical form for the whole string 1784 lf,leftover = _build_lf(string.strip()) 1785 if len(leftover.strip()): 1786 raise SemanticsStringBuildError, "could not parse the rest of the "\ 1787 "string '%s' in '%s'" % (leftover,string) 1788 1789 # Wrap it up in a Semantics 1790 return Semantics(lf) 1791

1792 -class SemanticsStringBuildError(Exception):

1793 pass

1794

1795 -class SemanticsPostProcessError(Exception):

1796 pass

1797

1798 -class KeyInferenceError(Exception):

1799 pass

1800

Source Code for Package jazzparser.formalisms.music_halfspan.semantics