scripts/livret.py

   1 from syllabify import *
   2
   3 class LilyVerse(Verse):
   4     def __init__(self, text):
   5         Verse.__init__(self, text)
   6
   7     def get_lily_text(self):
   8         return "\livretVerse#{} {{ {} }}".format(
   9             self.get_metric(),
  10             self.get_text())
  11
  12 class EludedVerse(LilyVerse):
  13     def __init__(self, text, forced_metric):
  14         LilyVerse.__init__(self, text)
  15         self._forced_metric = forced_metric
  16
  17     def get_metric(self):
  18         return self._forced_metric
  19
  20 class VersePart(LilyVerse):
  21     def __init__(self, text):
  22         LilyVerse.__init__(self, text)
  23         self._prev_part = []
  24         self._last_part = None
  25
  26     def set_last_part(self, last_part):
  27         self._last_part = last_part
  28
  29     def set_previous_parts(self, parts):
  30         self._prev_parts = parts
  31
  32     def get_previous_parts(self):
  33         return self._prev_parts
  34
  35     def get_metric(self):
  36         return self._last_part.get_metric()
  37
  38     def get_text(self):
  39         if self._prev_parts == []:
  40             return Verse.get_text(self)
  41         else:
  42             return "\\transparent {{ {} }} {}".format(
  43                 " ".join([Verse.get_text(part) for part in self._prev_parts]),
  44                 Verse.get_text(self))
  45
  46
  47 class VerseLastPart(VersePart):
  48     def __init__(self, text):
  49         VersePart.__init__(self, text)
  50
  51     def get_metric(self):
  52         metric = Verse.get_metric(self)
  53         for part in self.get_previous_parts():
  54             metric += Verse.get_metric(part)
  55         return metric
  56
  57 class LilyLine():
  58     def __init__(self, text):
  59         self._text = text
  60
  61     def syllabify(self, sign_tokenizer = None, syllable_tokenizer = None ):
  62         pass
  63
  64     def get_lily_text(self):
  65         return self._text
  66
  67 class Lilybretto():
  68     def __init__(self, language):
  69         self._lines = []
  70         self.language = language
  71
  72     def add_line(self, line):
  73         self._lines.append(line)
  74
  75     def get_lines(self):
  76         return self._lines
  77
  78     def syllabify(self):
  79         sign_tokenizer = SignTokenizer(language = self.language)
  80         syllable_tokenizer = SyllableTokenizerWithWordSeparation()
  81         for line in self._lines:
  82             line.syllabify(sign_tokenizer, syllable_tokenizer)
  83
  84
  85 class RawLibrettoReader():
  86     def __init__(self, language="fr"):
  87         self.language = language
  88
  89     def read(self, file):
  90         #file = open(filename, 'r')
  91         libretto = Lilybretto(self.language)
  92         verse_parts = []
  93         for line in file:
  94             verse_match = re.match(r"^%#(\S*) (.*)$", line)
  95             if verse_match:
  96                 # a verse
  97                 cmd = verse_match.group(1)
  98                 verse = verse_match.group(2).strip()
  99                 if cmd == "":
 100                     # a regular full verse
 101                     libretto.add_line(LilyVerse(verse))
 102                 elif cmd == "-":
 103                     # a split verse
 104                     verse_part = VersePart(verse)
 105                     verse_part.set_previous_parts(list(verse_parts))
 106                     verse_parts.append(verse_part)
 107                     libretto.add_line(verse_part)
 108                 elif cmd == "=":
 109                     last_part = VerseLastPart(verse)
 110                     last_part.set_previous_parts(verse_parts)
 111                     libretto.add_line(last_part)
 112                     for part in verse_parts:
 113                         part.set_last_part(last_part)
 114                     verse_parts = []
 115                 else:
 116                     # cmd is expected to be a number
 117                     # TODO: robustness/error handling
 118                     # an eluded verse
 119                     libretto.add_line(EludedVerse(verse, int(cmd)))
 120             else:
 121                 # a LilyPond line
 122                 libretto.add_line(LilyLine(line.rstrip()))
 123         return libretto
 124
 125 if __name__ == '__main__':
 126     parser = argparse.ArgumentParser(
 127         description='LilPond libretto generation.',
 128         formatter_class=argparse.ArgumentDefaultsHelpFormatter)
 129     parser.add_argument(
 130         '--language',
 131         default='fr',
 132         help='verse language (fr, it)')
 133     parser.add_argument(
 134         'files', metavar='FILE',
 135         type=argparse.FileType('r'),
 136         nargs='+',
 137         help='input files')
 138     args = vars(parser.parse_args())
 139     for file in args['files']:
 140         reader = RawLibrettoReader(args['language'])
 141         libretto = reader.read(file)
 142         libretto.syllabify()
 143         for line in libretto.get_lines():
 144             print(line.get_lily_text())