bin/poupdate

   1 #! /usr/bin/env python
   2 # Encoding: UTF-8
   3
   4 u"""Creation and loading of GNU Gettext language files.
   5
   6 poupdate [options] [file1.csv file2.csv ...]
   7
   8 Use this script to
   9 - Create .pot files (in pokedex/i18n/)
  10 - Update the .po files (in pokedex/i18n/<lang>)
  11 - Update the pokedex .csv files in (pokedex/data/csv/translations)
  12
  13 To make pos for a new language, make sure it is in the database, make
  14 a directory for it in pokedex/i18n/, and run this.
  15
  16 You can also give one or more translation CSVs as arguments.
  17 These are in the same format as veekun's main database CSVs, for example
  18 pokedex/data/csv/ability_prose.csv. Be sure to set the correct language
  19 ID (which implies the language must be in the database).
  20 Also be sure to have the correct column order: first an appropriately named
  21 foreign key, then local_language_id, and then the text columns.
  22
  23 """
  24
  25 # Everything related to Gettext files, and the CLI interface, is here.
  26 # General message handling and CSV I/O is in the pokedex library.
  27
  28 # Notes on how we use PO format:
  29 # The source information is stored in the occurences fields, using
  30 # "table_name.column_name" for file and object ID for line number. This is used
  31 # as a message key, instead of the source string. So it's important not to
  32 # discard location information. It also means "obsolete" and "fuzzy" mean
  33 # pretty much the same in our context.
  34 #
  35 # Also note that a pot file is just a po file with all strings untranslated.
  36 # So some functions here will work on either.
  37 #
  38 # Gettext context (msgctxt) is written to the files so that tools don't merge
  39 # unrelated strings together. It is ignored when reading the PO files.
  40
  41 # Also of note, "polib" means "(do) kiss!" in Czech.
  42
  43 import os
  44 import re
  45 import sys
  46 from datetime import datetime
  47 from optparse import OptionParser
  48 from collections import defaultdict
  49
  50 import pkg_resources
  51
  52 from pokedex.db import tables, translations
  53 from pokedex.defaults import get_default_csv_dir
  54
  55 try:
  56     import polib
  57 except ImportError:
  58     if __name__ == '__main__':
  59         exit('This utility needs polib installed.\n$ pip install polib')
  60     raise
  61
  62 number_replacement_flag = '-pokedex-number-replacement'
  63
  64 default_gettext_directory = pkg_resources.resource_filename('pokedex', 'i18n')
  65
  66 mapped_class_dict = dict((c.__name__, c) for c in tables.mapped_classes)
  67 for cls in tables.mapped_classes:
  68     mapped_class_dict.update(dict((c.__name__, cls) for c in cls.translation_classes))
  69
  70 class PokedexPot(polib.POFile):
  71     def __init__(self, name):
  72         super(PokedexPot, self).__init__()
  73         self.metadata = {
  74                 'Project-Id-Version': 'pokedex-%s 0.1' % name,
  75                 'Report-Msgid-Bugs-To': 'encukou@gmail.com',
  76                 'POT-Creation-Date': datetime.now().isoformat(),
  77                 'PO-Revision-Date': 'YEAR-MO-DA HO:MI+ZONE',
  78                 'MIME-Version': '1.0',
  79                 'Content-Type': 'text/plain; charset=utf-8',
  80                 'Content-Transfer-Encoding': '8bit',
  81                 'Generated-By': "The pokedex",
  82             }
  83         self.seen_entries = {}
  84
  85     def append(self, entry):
  86         """Append an entry. POEntries that only differ in numbers are merged.
  87
  88         For example "Route 1", "Route 2", etc. are replaced by a single
  89         "Route {num}".
  90
  91         Multiple numbers might be replaced, for example in "{num}--{num}
  92         different Unown caught"
  93
  94         Entries without numbers are merged as well (e.g. "Has no overworld
  95         effect" appears quite a few times in in AbilityChangelog)
  96         """
  97         replaced = translations.number_re.sub('{num}', entry.msgid)
  98         try:
  99             common_entry = self.seen_entries[(entry.msgctxt, replaced)]
 100         except KeyError:
 101             self.seen_entries[(entry.msgctxt, replaced)] = entry
 102         else:
 103             common_entry.occurrences += entry.occurrences
 104             # Only now is the actual entry replaced. So we get
 105             # "Route {num}", but "Porygon2" because there's no Porygon3.
 106             common_entry.msgid = replaced
 107             common_entry.msgstr = translations.number_re.sub('{num}', common_entry.msgstr)
 108             if replaced != entry.msgid and number_replacement_flag not in common_entry.flags:
 109                 common_entry.flags.append(number_replacement_flag)
 110             return
 111         self += [entry]
 112
 113 class PotDict(dict):
 114     """A defaultdict of pot files"""
 115     def __missing__(self, name):
 116         pot = PokedexPot(name)
 117         self[name] = pot
 118         return pot
 119
 120 def yield_po_messages(pos):
 121     """Yield messages from all given .po files
 122     """
 123     merger = translations.Merge()
 124     for po in pos.values():
 125         merger.add_iterator(_yield_one_po_messages(po, merger))
 126     return merger
 127
 128 def entry_sort_key(entry):
 129     try:
 130         cls_col, line = entry.occurrences[0]
 131     except IndexError:
 132         return
 133     else:
 134         if line:
 135             classname, col = cls_col.split('.')
 136             fuzzy = entry.obsolete or 'fuzzy' in entry.flags
 137             try:
 138                 cls = mapped_class_dict[classname]
 139             except KeyError, k:
 140                 # Renamed table?
 141                 print 'Warning: Unknown class %s' % classname
 142                 return '', int(line), col, fuzzy
 143             else:
 144                 return cls.__name__, int(line), col, fuzzy
 145
 146 def _yield_one_po_messages(pofile, merger):
 147     # Yield messages from one po file
 148     #
 149     # Messages in our po files are ordered by the first occurrence.
 150     # The occurrences of a single message are also ordered.
 151     # So just merge all the subsequences as we go
 152     for entry in sorted(pofile, key=entry_sort_key):
 153         if entry.msgstr:
 154             fuzzy = (entry.obsolete or 'fuzzy' in entry.flags)
 155             messages = []
 156             for occurrence in entry.occurrences:
 157                 cls_colname, id = occurrence
 158                 if id:
 159                     clsname, colname = cls_colname.split('.')
 160                     cls = mapped_class_dict[clsname]
 161                     messages.append(translations.Message(
 162                             mapped_class_dict[clsname].__name__,
 163                             int(id),
 164                             colname,
 165                             entry.msgstr,
 166                             source=entry.msgid,
 167                             number_replacement=number_replacement_flag in entry.flags,
 168                             origin='PO file',
 169                             fuzzy=fuzzy,
 170                         ))
 171             if messages[1:]:
 172                 # Spawn extra iterators before yielding
 173                 merger.add_iterator(messages[1:])
 174             if messages:
 175                 yield messages[0]
 176
 177 def create_pots(source, *translation_streams):
 178     """Convert an iterator of Messages to a dictionary of pot/po files
 179
 180     If translations are given, they're merged, and any exact matches are put
 181     in the po file. Give some for po files, don't give any for pot files.
 182     """
 183     obsolete = []
 184     pots = PotDict()
 185     merged = translations.merge_translations(source, *translation_streams, unused=obsolete.append)
 186     for source, sourcehash, string, exact in merged:
 187         ctxt = '.'.join((source.cls, source.colname))
 188         entry = polib.POEntry(
 189                 msgid=source.string,
 190                 occurrences=[(ctxt, source.id)],
 191                 msgctxt=ctxt,
 192             )
 193         if string:
 194             entry.msgstr = string
 195             if not exact:
 196                 entry.flags.append('fuzzy')
 197         pots[source.pot].append(entry)
 198     for message in obsolete:
 199         ctxt = '.'.join((message.cls, message.colname))
 200         entry = polib.POEntry(
 201                 msgid=message.source or '???',
 202                 occurrences=[(ctxt, message.id)],
 203                 msgctxt=ctxt,
 204                 obsolete=True,
 205             )
 206     return pots
 207
 208 def save_pots(pots, gettext_directory=default_gettext_directory):
 209     """Save pot files to a directory."""
 210     for name, pot in pots.items():
 211         pot.save(os.path.join(gettext_directory, 'pokedex-%s.pot' % name))
 212
 213 def save_pos(pos, lang, gettext_directory=default_gettext_directory):
 214     """Save po files to the appropriate directory."""
 215     for name, po in pos.items():
 216         po.save(os.path.join(gettext_directory, lang, 'pokedex-%s.po' % name))
 217
 218 def read_pots(directory=default_gettext_directory, extension='.pot'):
 219     """Read all files from the given directory with the given extension as pofiles
 220
 221     Works on pos or pots.
 222     """
 223     pots = {}
 224     for filename in os.listdir(directory):
 225         basename, ext = os.path.splitext(filename)
 226         if ext == extension:
 227             pots[basename] = polib.pofile(os.path.join(directory, filename))
 228
 229     return pots
 230
 231 def all_langs(gettext_directory=default_gettext_directory):
 232     return [
 233             d for d in os.listdir(gettext_directory)
 234             if os.path.isdir(os.path.join(gettext_directory, d))
 235         ]
 236
 237 def merge_pos(transl, lang, language_directory):
 238     """Update all po files for the given language
 239
 240     Takes into account the source, the official translations from the database,
 241     the existing PO files, and the current translation CSV, in that order.
 242
 243     Returns a name -> pofile dict
 244     """
 245     return create_pots(
 246             transl.source,
 247             transl.official_messages(lang),
 248             yield_po_messages(pos=read_pots(language_directory, '.po')),
 249             transl.yield_target_messages(lang),
 250         )
 251
 252 def bar(fraction, size, done_char='=', split_char='|', notdone_char='-'):
 253     """Build an ASCII art progress bar
 254     """
 255     size -= 1
 256     if fraction == 1:
 257         split_char = done_char
 258     completed = int(round(size * fraction))
 259     bar = [done_char] * completed
 260     bar.append(split_char)
 261     bar += notdone_char * (size - completed)
 262     return ''.join(bar)
 263
 264 def print_stats(pos):
 265     """Print out some fun stats about a set of po files
 266     """
 267     template = u"{0:>10}: {1:4}/{2:4} {3:6.2f}% [{4}]"
 268     total_translated = 0
 269     total = 0
 270     for name, po in pos.items():
 271         num_translated = len(po.translated_entries())
 272         total_translated += num_translated
 273         fraction_translated = 1. * num_translated / len(po)
 274         total += len(po)
 275         print template.format(
 276                 name,
 277                 num_translated,
 278                 len(po),
 279                 100 * fraction_translated,
 280                 bar(fraction_translated, 47),
 281             ).encode('utf-8')
 282     fraction_translated = 1. * total_translated / total
 283     print template.format(
 284             'Total',
 285             total_translated,
 286             total,
 287             100 * fraction_translated,
 288             bar(fraction_translated, 47),
 289         ).encode('utf-8')
 290
 291
 292 if __name__ == '__main__':
 293     parser = OptionParser(__doc__)
 294
 295     parser.add_option('-l', '--langs', dest='langs',
 296             help="List of languages to handle, separated by commas (example: -l 'en,de,ja') (default: all in gettext directory)")
 297     parser.add_option('-P', '--no-pots', dest='pots', action='store_false', default=True,
 298             help='Do not create POT files (templates)')
 299     parser.add_option('-p', '--no-pos', dest='pos', action='store_false', default=True,
 300             help='Do not update PO files (message catalogs)')
 301
 302     parser.add_option('-c', '--no-csv', dest='csv', action='store_false', default=True,
 303             help='Do not update pokedex translations files')
 304
 305     parser.add_option('-d', '--directory', dest='directory',
 306             help='Veekun data directory')
 307     parser.add_option('-L', '--source-language', dest='source_lang',
 308             help="Source language identifier (default: 'en')")
 309
 310     parser.add_option('-g', '--gettext-dir', dest='gettext_directory', default=default_gettext_directory,
 311             help='Gettext directory (default: pokedex/i18n/)')
 312
 313     parser.add_option('-q', '--quiet', dest='verbose', default=True, action='store_false',
 314             help="Don't print what's going on")
 315
 316     options, arguments = parser.parse_args()
 317
 318     transl = translations.Translations.from_parsed_options(options)
 319
 320     gettext_directory = options.gettext_directory
 321     if options.pots:
 322         if options.verbose:
 323             print 'Creating pots in', gettext_directory
 324         save_pots(create_pots(transl.source), gettext_directory=gettext_directory)
 325
 326     if options.pos or options.csv:
 327         # Merge in CSV files from command line
 328         csv_streams = defaultdict(translations.Merge)
 329         for argument in arguments:
 330             # Add each message in its own stream, to sort them.
 331             file = open(argument, 'rb')
 332             with file:
 333                 for message in translations.yield_guessed_csv_messages(file):
 334                     lang = transl.language_identifiers[message.language_id]
 335                     csv_streams[lang].add_iterator([message])
 336         streams = defaultdict(list)
 337         for lang, stream in csv_streams.items():
 338             streams[lang].append(stream)
 339
 340         # Merge in the PO files
 341         if options.langs:
 342             langs = options.langs.split(',')
 343         else:
 344             langs = all_langs(gettext_directory)
 345
 346         for lang in langs:
 347             language_directory = os.path.join(gettext_directory, lang)
 348             if options.verbose:
 349                 print 'Merging translations for %s in %s' % (lang, language_directory)
 350             pos = merge_pos(transl, lang, language_directory)
 351
 352             if options.pos:
 353                 if options.verbose:
 354                     print 'Writing POs for %s' % lang
 355                 save_pos(pos, lang, gettext_directory=gettext_directory)
 356
 357                 if options.verbose:
 358                     print_stats(pos)
 359
 360             streams[lang].append(yield_po_messages(pos))
 361
 362     if options.csv:
 363         for lang, lang_streams in streams.items():
 364             if options.verbose:
 365                 print "Merging %s translation stream/s for '%s'" % (len(lang_streams), lang)
 366             existing_messages = list(transl.yield_target_messages(lang))
 367             lang_streams.append(existing_messages)
 368             transl.write_translations(lang, *lang_streams)