]> git.donarmstrong.com Git - lilypond.git/blob - scripts/auxiliar/translations-status.py
translations-status.py: Replace if top: by polymorphism.
[lilypond.git] / scripts / auxiliar / translations-status.py
1 #!/usr/bin/env python
2
3 '''
4 USAGE: cd Documentation && translations-status.py
5
6   Write:
7     translations.itexi
8     <LANG>/translations.itexi
9     out/translations-status.txt
10
11   Update word counts in:
12     contributor/doc-translation-list.itexi
13 '''
14
15 import sys
16 import re
17 import string
18 import operator
19 import os
20 #
21 import langdefs
22 import buildlib
23
24 def progress (str):
25     sys.stderr.write (str + '\n')
26
27 exit_code = 0
28
29 def error (str, update_status=1):
30     global exit_code
31     sys.stderr.write ('translations-status.py: %s\n' % str)
32     exit_code = max (exit_code, update_status)
33
34 progress ("translations-status.py")
35
36 _doc = lambda s: s
37
38 # load gettext messages catalogs
39 translation = langdefs.translation
40
41
42 language_re = re.compile (r'^@documentlanguage (.+)', re.M)
43 comments_re = re.compile (r'^@ignore\n(.|\n)*?\n@end ignore$|@c .*?$', re.M)
44 space_re = re.compile (r'\s+', re.M)
45 lilypond_re = re.compile (r'@lilypond({.*?}|(.|\n)*?\n@end lilypond$)', re.M)
46 node_re = re.compile ('^@node .*?$', re.M)
47 title_re = re.compile ('^@(settitle|chapter|top|(?:sub){0,2}section|'
48                            '(?:unnumbered|appendix)(?:(?:sub){0,2}sec)?) (.*?)$', re.M)
49 include_re = re.compile ('^@include (.*?)$', re.M)
50
51 # allow multiple lines
52 translators_re = re.compile (r'^@c[ ]+[Tt]ranslators?[ ]*:[ ]*(.*?)$', re.M)
53 checkers_re = re.compile (r'^@c[ ]+[Tt]ranslation[ ]*[Cc]heckers?[ ]*:[ ]*(.*?)$', re.M)
54 status_re = re.compile (r'^@c[ ]+[Tt]ranslation[ ]*[Ss]tatus[ ]*:[ ]*(.*?)$', re.M)
55 post_gdp_re = re.compile ('post.GDP', re.I)
56 untranslated_node_str = '@untranslated'
57 skeleton_str = '-- SKELETON FILE --'
58
59 section_titles_string = _doc ('Section titles')
60 last_updated_string = _doc (' <p><i>Last updated %s</i></p>\n')
61 detailed_status_heads = [_doc ('Translators'), _doc ('Translation checkers'),
62                          _doc ('Translated'), _doc ('Up to date'),
63                          _doc ('Other info')]
64 format_table = {
65     'not translated': {'color':'d0f0f8', 'short':_doc ('no'), 'abbr':'NT',
66                        'long':_doc ('not translated')},
67     'partially translated': {'color':'dfef77',
68                              'short':_doc ('partially (%(p)d %%)'),
69                              'abbr':'%(p)d%%',
70                              'long':_doc ('partially translated (%(p)d %%)')},
71     'fully translated': {'color':'1fff1f', 'short':_doc ('yes'), 'abbr':'FT',
72                          'long': _doc ('translated')},
73     'up to date': {'short':_doc ('yes'), 'long':_doc ('up to date'),
74                    'abbr':'100%%', 'vague':_doc ('up to date')},
75     'outdated': {'short':_doc ('partially'), 'abbr':'%(p)d%%',
76                  'vague':_doc ('partially up to date')},
77     'N/A': {'short':_doc ('N/A'), 'abbr':'N/A', 'color':'d587ff', 'vague':''},
78     'pre-GDP':_doc ('pre-GDP'),
79     'post-GDP':_doc ('post-GDP')
80 }
81
82 texi_level = {
83 # (Unumbered/Numbered/Lettered, level)
84     'top': ('u', 0),
85     'unnumbered': ('u', 1),
86     'unnumberedsec': ('u', 2),
87     'unnumberedsubsec': ('u', 3),
88     'chapter': ('n', 1),
89     'section': ('n', 2),
90     'subsection': ('n', 3),
91     'appendix': ('l', 1),
92     'appendixsec': ('l', 2),
93 }
94
95 appendix_number_trans = string.maketrans ('@ABCDEFGHIJKLMNOPQRSTUVWXY',
96                                           'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
97
98 class SectionNumber (object):
99     def __init__ (self):
100         self.__data = [[0,'u']]
101
102     def __increase_last_index (self):
103         type = self.__data[-1][1]
104         if type == 'l':
105             self.__data[-1][0] = \
106                 self.__data[-1][0].translate (appendix_number_trans)
107         elif type == 'n':
108             self.__data[-1][0] += 1
109
110     def format (self):
111         if self.__data[-1][1] == 'u':
112             return ''
113         return '.'.join ([str (i[0]) for i in self.__data if i[1] != 'u']) + ' '
114
115     def increase (self, (type, level)):
116         if level == 0:
117             self.__data = [[0,'u']]
118         while level + 1 < len (self.__data):
119             del self.__data[-1]
120         if level + 1 > len (self.__data):
121             self.__data.append ([0, type])
122             if type == 'l':
123                 self.__data[-1][0] = '@'
124         if type == self.__data[-1][1]:
125             self.__increase_last_index ()
126         else:
127             self.__data[-1] = ([0, type])
128             if type == 'l':
129                 self.__data[-1][0] = 'A'
130             elif type == 'n':
131                 self.__data[-1][0] = 1
132         return self.format ()
133
134
135 def percentage_color (percent):
136     p = percent / 100.0
137     if p < 0.33:
138         c = [hex (int (3 * p * b + (1 - 3 * p) * a))[2:]
139              for (a, b) in [(0xff, 0xff), (0x5c, 0xa6), (0x5c, 0x4c)]]
140     elif p < 0.67:
141         c = [hex (int ((3 * p - 1) * b + (2 - 3 * p) * a))[2:]
142              for (a, b) in [(0xff, 0xff), (0xa6, 0xff), (0x4c, 0x3d)]]
143     else:
144         c = [hex (int ((3 * p - 2) * b + 3 * (1 - p) * a))[2:]
145              for (a, b) in [(0xff, 0x1f), (0xff, 0xff), (0x3d, 0x1f)]]
146     return ''.join (c)
147
148
149 def update_word_count (text, filename, word_count):
150     return re.sub (r'(?m)^(\d+) *' + filename,
151                    str (word_count).ljust (6) + filename,
152                    text)
153
154 po_msgid_re = re.compile (r'^msgid "(.*?)"(?:\n"(.*?)")*', re.M)
155
156 def po_word_count (po_content):
157     s = ' '.join ([''.join (t) for t in po_msgid_re.findall (po_content)])
158     return len (space_re.split (s))
159
160 sgml_tag_re = re.compile (r'<.*?>', re.S)
161
162 def sgml_word_count (sgml_doc):
163     s = sgml_tag_re.sub ('', sgml_doc)
164     return len (space_re.split (s))
165
166 def tely_word_count (tely_doc):
167     '''
168     Calculate word count of a Texinfo document node by node.
169
170     Take string tely_doc as an argument.
171     Return a list of integers.
172
173     Texinfo comments and @lilypond blocks are not included in word counts.
174     '''
175     tely_doc = comments_re.sub ('', tely_doc)
176     tely_doc = lilypond_re.sub ('', tely_doc)
177     nodes = node_re.split (tely_doc)
178     return [len (space_re.split (n)) for n in nodes]
179
180
181 class TelyDocument (object):
182     def __init__ (self, filename):
183         self.filename = filename
184         self.contents = 'GIT committish: 0'
185         if os.path.exists (filename):
186             self.contents = open (filename).read ()
187         ## record title and sectionning level of first Texinfo section
188         self.sectioning = 'unnumbered'
189         self.title = 'Untitled'
190         m = title_re.search (self.contents)
191         if m:
192             self.sectioning = m.group (1)
193             self.title = m.group (2)
194
195         if not hasattr (self, 'language'):
196             self.language = ''
197         m = language_re.search (self.contents)
198         if m:
199             self.language = m.group (1)
200
201         dir = os.path.dirname (filename).split ('/')[0]
202         if len (dir) == 2:
203             dir += '/'
204         else:
205             dir = ''
206         included_files = [dir + t
207                           for t in include_re.findall (self.contents)]
208         self.included_files = [p for p in included_files if os.path.exists (p)]
209
210     def get_level (self):
211         return texi_level [self.sectioning]
212
213     def print_title (self, section_number):
214         if not hasattr (self, 'level'):
215             self.level = self.get_level ()
216         return section_number.increase (self.level) + self.title
217
218
219 class TranslatedTelyDocument (TelyDocument):
220     def __init__ (self, filename, masterdocument, parent_translation=None):
221         TelyDocument.__init__ (self, filename)
222         self.masterdocument = masterdocument
223         if not hasattr (self, 'language'):
224             self.language = ''
225         if not self.language and parent_translation:
226             self.language = parent_translation.__dict__.get ('language', '')
227         if self.language == 'en':
228             print filename + ': language en specified: set @documentlanguage', self.filename[:2]
229             self.language = ''
230         if not self.language and filename[2] == '/':
231             print filename + ': no language specified: add @documentlanguage', self.filename[:2]
232             self.language = filename[:2]
233         if self.language:
234             self.translation = translation[self.language]
235         else:
236             self.translation = lambda x: x
237         self.title = self.translation (self.title)
238
239         ## record authoring information
240         self.translators = ['']
241         if parent_translation:
242             self.translators = parent_translation.__dict__.get ('translators', [''])
243         m = translators_re.findall (self.contents)
244         if m:
245             self.translators = [n.strip () for n in
246                                 reduce (operator.add, [n.split (',') for n in m])]
247         if self.language != self.filename[:2]:
248             print 'Barf:', self.filename
249             barf
250         if (not isinstance (self, UntranslatedTelyDocument)
251             and (not self.translators or not self.translators[0])
252             and not 'macros.itexi' in self.filename):
253             error (self.filename + ''': error: no translator name found
254 please specify one ore more lines in the master file
255 @c Translator: FirstName LastName[, FirstName LastName]..''')
256         self.checkers = []
257         m = checkers_re.findall (self.contents)
258         if m:
259             self.checkers = [n.strip () for n in
260                              reduce (operator.add, [n.split (',') for n in m])]
261         if not self.checkers and isinstance (parent_translation, TranslatedTelyDocument):
262             self.checkers = parent_translation.checkers
263
264         ## check whether translation is pre- or post-GDP
265         m = status_re.search (self.contents)
266         if m:
267             self.post_gdp = bool (post_gdp_re.search (m.group (1)))
268         else:
269             self.post_gdp = False
270
271         ## record which parts (nodes) of the file are actually translated
272         self.partially_translated = not skeleton_str in self.contents
273         nodes = node_re.split (self.contents)
274         self.translated_nodes = [not untranslated_node_str in n for n in nodes]
275
276         ## calculate translation percentage
277         master_total_word_count = sum (masterdocument.word_count)
278         translation_word_count = \
279             sum ([masterdocument.word_count[k] * self.translated_nodes[k]
280                   for k in range (min (len (masterdocument.word_count),
281                                        len (self.translated_nodes)))])
282         self.translation_percentage = \
283             100 * translation_word_count / master_total_word_count
284
285         ## calculate how much the file is outdated
286         (diff_string, git_error) = \
287             buildlib.check_translated_doc (masterdocument.filename, self.filename, self.contents)
288         if git_error:
289             sys.stderr.write ('warning: %s: %s' % (self.filename, git_error))
290             self.uptodate_percentage = None
291         else:
292             diff = diff_string.splitlines ()
293             insertions = sum ([len (l) - 1 for l in diff
294                                if l.startswith ('+')
295                                and not l.startswith ('+++')])
296             deletions = sum ([len (l) - 1 for l in diff
297                               if l.startswith ('-')
298                               and not l.startswith ('---')])
299             outdateness_percentage = 50.0 * (deletions + insertions) / \
300                 (masterdocument.size + 0.5 * (deletions - insertions))
301             self.uptodate_percentage = 100 - int (outdateness_percentage)
302             if self.uptodate_percentage > 100:
303                 alternative = 50
304                 progress ("%s: strange uptodateness percentage %d %%, \
305 setting to %d %%" % (self.filename, self.uptodate_percentage, alternative))
306                 self.uptodate_percentage = alternative
307             elif self.uptodate_percentage < 1:
308                 alternative = 1
309                 progress ("%s: strange uptodateness percentage %d %%, \
310 setting to %d %%" % (self.filename, self.uptodate_percentage, alternative))
311                 self.uptodate_percentage = alternative
312
313     def get_level (self):
314         return texi_level ['top']
315
316     def completeness (self, formats=['long'], translated=False):
317         if translated:
318             translation = self.translation
319         else:
320             translation = lambda x: x
321
322         if isinstance (formats, str):
323             formats = [formats]
324         p = self.translation_percentage
325         if p == 0:
326             status = 'not translated'
327         elif p == 100:
328             status = 'fully translated'
329         else:
330             status = 'partially translated'
331         return dict ([(f, translation (format_table[status][f]) % locals())
332                       for f in formats])
333
334     def uptodateness (self, formats=['long'], translated=False):
335         if translated:
336             translation = self.translation
337         else:
338             translation = lambda x: x
339
340         if isinstance (formats, str):
341             formats = [formats]
342         p = self.uptodate_percentage
343         if p == None:
344             status = 'N/A'
345         elif p == 100:
346             status = 'up to date'
347         else:
348             status = 'outdated'
349         l = {}
350         for f in formats:
351             if f == 'color' and p != None:
352                 l['color'] = percentage_color (p)
353             else:
354                 l[f] = translation (format_table[status][f]) % locals ()
355         return l
356
357     def gdp_status (self):
358         if self.post_gdp:
359             return self.translation (format_table['post-GDP'])
360         else:
361             return self.translation (format_table['pre-GDP'])
362
363     def short_texi_status (self):
364         s = '  <td title="%(filename)s">' % self.__dict__
365         if self.partially_translated:
366             s += '<br>\n   '.join (self.translators) + '<br>\n'
367             if self.checkers:
368                 s += '   <small>' + \
369                     '<br>\n   '.join (self.checkers) + '</small><br>\n'
370
371         c = self.completeness (['color', 'long'])
372         s += '   <span style="background-color: #%(color)s">\
373 %(long)s</span><br>\n' % c
374
375         if self.partially_translated:
376             u = self.uptodateness (['vague', 'color'])
377             s += '   <span style="background-color: #%(color)s">\
378 %(vague)s</span><br>\n' % u
379
380         s += '  </td>\n'
381         return s
382
383     def text_status (self):
384         s = self.completeness ('abbr')['abbr'] + ' '
385
386         if self.partially_translated:
387             s += self.uptodateness ('abbr')['abbr'] + ' '
388         return s
389
390     def texi_status (self, numbering=SectionNumber ()):
391         s = '''<table align="center" border="2">
392  <tr align="center">
393   <th>%s</th>''' % self.print_title (numbering)
394         s += ''.join (['  <th>%s</th>\n' % self.translation (h)
395                        for h in detailed_status_heads])
396         s += ' </tr>\n'
397         s += (' <tr align="left">\n  <td title="%%(filename)s">%s<br>(%d)</td>\n'
398               % (self.translation (section_titles_string),
399                  sum (self.masterdocument.word_count))) % self.__dict__
400         s += self.texi_body (numbering)
401         s += '</table>\n<p></p>\n'
402         return s
403
404     def texi_body (self, numbering):
405         return (self.texi_translators ()
406                 + self.texi_completeness ()
407                 + self.texi_uptodateness ()
408                 + self.texi_gdp ()
409                 + self.texi_translations (numbering))
410
411     def texi_translators (self):
412         if self.partially_translated:
413             return ('  <td>' + '<br>\n   '.join (self.translators) + '</td>\n'
414                     + '  <td>' + '<br>\n   '.join (self.checkers) + '</td>\n')
415         return '  <td></td>\n' * 2
416
417     def texi_completeness (self):
418         c = self.completeness (['color', 'short'], translated=True)
419         return '  <td><span style="background-color: #%(color)s">\
420 %(short)s</span></td>\n' % {'color': c['color'],
421                            'short': c['short']}
422
423     def texi_uptodateness (self):
424         if self.partially_translated:
425             u = self.uptodateness (['short', 'color'], translated=True)
426             return '  <td><span style="background-color: #%(color)s">\
427 %(short)s</span></td>\n' % {'color': u['color'],
428                            'short': u['short']}
429         return '  <td></td>\n'
430
431     def texi_gdp (self):
432         return '  <td>' + self.gdp_status () + '</td>\n </tr>\n'
433
434     def texi_translations (self, numbering):
435         return ''.join ([i.translations[self.language].texi_status (numbering)
436                          for i in self.masterdocument.includes
437                          if self.language in i.translations])
438
439 class IncludedTranslatedTelyDocument (TranslatedTelyDocument):
440     get_level = TelyDocument.get_level
441     def texi_status (self, numbering=SectionNumber ()):
442         if self.title != 'Untitled':
443             return ((' <tr align="left">\n  <td title="%%(filename)s">%s<br>(%d)</td>\n'
444                      % (self.print_title (numbering),
445                         sum (self.masterdocument.word_count))) % self.__dict__
446                     + self.texi_body (numbering))
447         return ''
448
449 class UntranslatedTelyDocument (TranslatedTelyDocument):
450     def __init__ (self, filename, masterdocument, parent_translation=None):
451         if filename[2] == '/':
452             self.language = filename[:2]
453         TranslatedTelyDocument.__init__ (self, filename, masterdocument, parent_translation)
454
455 class IncludedUntranslatedTelyDocument (UntranslatedTelyDocument, IncludedTranslatedTelyDocument):
456     get_level = TelyDocument.get_level
457
458 class MasterTelyDocument (TelyDocument):
459     def __init__ (self,
460                   filename,
461                   parent_translations=dict ([(lang, None)
462                                              for lang in langdefs.LANGDICT])):
463         TelyDocument.__init__ (self, filename)
464         self.size = len (self.contents)
465         self.word_count = tely_word_count (self.contents)
466         self.translations = {}
467         self.includes = []
468         if not self.language or self.language == 'en':
469             languages = [x for x in parent_translations.keys () if x != 'en']
470             self.translations = dict ([x for x in
471                                        [(lang, self.translated_factory (os.path.join (lang, self.filename),
472                                                                         parent_translations.get (lang)))
473                                         for lang in languages]
474                                        if x[1]])
475             if self.translations:
476                 self.includes = [IncludedMasterTelyDocument (f, self.translations)
477                                  for f in self.included_files]
478
479     def get_level (self):
480         return texi_level ['top']
481
482     def translated_factory (self, filename, parent):
483         if os.path.exists (filename):
484             return TranslatedTelyDocument (filename, self, parent)
485         return None
486
487     def update_word_counts (self, s):
488         s = update_word_count (s, self.filename, sum (self.word_count))
489         for i in self.includes:
490             s = i.update_word_counts (s)
491         return s
492
493     def texi_status (self, numbering=SectionNumber ()):
494         s = '''<table align="center" border="2">
495  <tr align="center">
496   <th>%s</th>''' % self.print_title (numbering)
497         s += ''.join (['  <th>%s</th>\n' % l for l in sorted (self.translations.keys ())])
498         s += ' </tr>\n'
499         s += (' <tr align="left">\n  <td title="%%(filename)s">Section titles<br>(%d)</td>\n'
500               % sum (self.word_count)) % self.__dict__
501         s += self.texi_body (numbering)
502         s += '</table>\n<p></p>\n'
503         return s
504
505     def texi_body (self, numbering):
506         return (''.join ([self.translations[k].short_texi_status ()
507                           for k in sorted (self.translations.keys ())])
508                 + ' </tr>\n'
509                 + ''.join ([i.texi_status (numbering) for i in self.includes]))
510
511     def text_status (self, numbering=SectionNumber (), colspec=[48,12]):
512         s = (self.print_title (numbering) + ' ').ljust (colspec[0])
513         s += ''.join (['%s'.ljust (colspec[1]) % l
514                        for l in sorted (self.translations.keys ())])
515         s += '\n'
516         s += ('Section titles (%d)' % \
517                   sum (self.word_count)).ljust (colspec[0])
518         s += self.text_body (numbering, colspec)
519         s += '\n'
520         return s
521
522     def text_body (self, numbering, colspec):
523         return (''.join ([self.translations[k].text_status ().ljust(colspec[1])
524                           for k in sorted (self.translations.keys ())])
525                 + '\n\n'
526                 + ''.join ([i.text_status (numbering) for i in self.includes]))
527
528 class IncludedMasterTelyDocument (MasterTelyDocument):
529     get_level = TelyDocument.get_level
530
531     def translated_factory (self, filename, parent):
532         if os.path.exists (filename):
533             return IncludedTranslatedTelyDocument (filename, self, parent)
534         return IncludedUntranslatedTelyDocument (filename, self, parent)
535
536     def texi_status (self, numbering=SectionNumber ()):
537         if self.title != 'Untitled':
538             return ((' <tr align="left">\n  <td title=%%(filename)s>%s<br>(%d)</td>\n'
539                      % (self.print_title (numbering), sum (self.word_count))) % self.__dict__
540                     + self.texi_body (numbering))
541         return ''
542
543     def text_status (self, numbering=SectionNumber (), colspec=[48,12]):
544         if self.title != 'Untitled':
545             return (('%s (%d) '
546                      % (self.print_title (numbering), sum (self.word_count)))
547                     + self.text_body (numbering, colspec)
548                     ).ljust (colspec[0])
549         return ''
550
551
552 update_category_word_counts_re = re.compile (r'(?ms)^-(\d+)-(.*?\n)\d+ *total')
553
554 counts_re = re.compile (r'(?m)^(\d+) ')
555
556 def update_category_word_counts_sub (m):
557     return ('-' + m.group (1) + '-' + m.group (2)
558             + str (sum ([int (c)
559                          for c in counts_re.findall (m.group (2))])).ljust (6)
560             + 'total')
561
562 # urg 
563 # main () starts here-abouts
564
565 progress ("Reading documents...")
566
567 master_files = \
568     buildlib.read_pipe ("git ls-files | grep -E '[^/]*/?[^/]*[.](tely|texi)$'")[0].splitlines ()
569 master_files.sort ()
570 master_docs = [MasterTelyDocument (os.path.normpath (filename))
571                for filename in master_files]
572 master_docs = [doc for doc in master_docs if doc.translations]
573
574 enabled_languages = [l for l in langdefs.LANGDICT
575                      if langdefs.LANGDICT[l].enabled
576                      and l != 'en']
577
578 progress ("Generating status pages...")
579
580 date_time = buildlib.read_pipe ('LANG= date -u')[0]
581
582 main_status_body = last_updated_string % date_time
583 main_status_body += '\n'.join ([doc.texi_status () for doc in master_docs])
584
585 texi_header = '''@c -*- coding: utf-8; mode: texinfo; -*-
586 @c This file was generated by translation-status.py -- DO NOT EDIT!
587 @ignore
588     Translation of GIT committish: 0
589 @end ignore
590
591 @ifnothtml
592 Translation status currently only available in HTML.
593 @end ifnothtml
594 @ifhtml
595 @html
596 '''
597
598 texi_footer = '''
599 @end html
600 @end ifhtml
601 '''
602
603 main_status_page = texi_header % locals () + main_status_body + texi_footer
604
605 open ('translations.itexi', 'w').write (main_status_page)
606
607 for l in enabled_languages:
608     date_time = buildlib.read_pipe ('LANG=%s date -u' % l)[0]
609     updated = translation[l] (last_updated_string) % date_time
610     texi_status = '\n'.join ([doc.translations[l].texi_status ()
611                               for doc in master_docs
612                               if l in doc.translations])
613     lang_status_page = texi_header + updated + texi_status + texi_footer
614     open (os.path.join (l, 'translations.itexi'), 'w').write (lang_status_page)
615
616 main_status_txt = '''Documentation translations status
617 Generated %s
618 NT = not translated
619 FT = fully translated
620
621 ''' % date_time
622
623 main_status_txt += '\n'.join ([doc.text_status () for doc in master_docs])
624
625 status_txt_file = 'out/translations-status.txt'
626 progress ("Writing %s..." % status_txt_file)
627 open (status_txt_file, 'w').write (main_status_txt)
628
629 translation_instructions_file = 'contributor/doc-translation-list.itexi'
630 progress ("Updating %s..." % translation_instructions_file)
631 translation_instructions = open (translation_instructions_file).read ()
632
633 for doc in master_docs:
634     translation_instructions = doc.update_word_counts (translation_instructions)
635
636 for html_file in re.findall (r'(?m)^\d+ *(\S+?\.html\S*?)(?: |$)',
637                              translation_instructions):
638     word_count = sgml_word_count (open (html_file).read ())
639     translation_instructions = update_word_count (translation_instructions,
640                                                   html_file,
641                                                   word_count)
642
643 for po_file in re.findall (r'(?m)^\d+ *(\S+?\.po\S*?)(?: |$)',
644                            translation_instructions):
645     word_count = po_word_count (open (po_file).read ())
646     translation_instructions = update_word_count (translation_instructions,
647                                                   po_file,
648                                                   word_count)
649
650 translation_instructions = \
651     update_category_word_counts_re.sub (update_category_word_counts_sub,
652                                         translation_instructions)
653
654 open (translation_instructions_file, 'w').write (translation_instructions)
655 sys.exit (exit_code)