1   
  2   
  3   
  4   
  5   
  6   
  7   
  8   
  9   
 10   
 11   
 12   
 13   
 14   
 15   
 16   
 17   
 18   
 19   
 20   
 21   
 22   
 23  """convert XLIFF localization files to an OpenOffice.org (SDF) localization file""" 
 24   
 25  import sys 
 26  import os 
 27  from translate.storage import oo 
 28  from translate.storage import factory 
 29  from translate.filters import pofilter 
 30  from translate.filters import checks 
 31  from translate.filters import autocorrect  
 32  import time 
 33   
 35 -    def __init__(self, templatefile, languages=None, timestamp=None, includefuzzy=False, long_keys=False, filteraction="exclude"): 
  36          """construct a reoo converter for the specified languages (timestamp=0 means leave unchanged)""" 
 37           
 38          self.long_keys = long_keys 
 39          self.readoo(templatefile) 
 40          self.languages = languages 
 41          self.filteraction = filteraction 
 42          if timestamp is None: 
 43              self.timestamp = time.strptime("2002-02-02 02:02:02", "%Y-%m-%d %H:%M:%S") 
 44          else: 
 45              self.timestamp = timestamp 
 46          if self.timestamp: 
 47              self.timestamp_str = time.strftime("%Y-%m-%d %H:%M:%S", self.timestamp) 
 48          else: 
 49              self.timestamp_str = None 
 50          self.includefuzzy = includefuzzy 
  51   
 53          """converts an oo key tuple into a key identifier for the source file""" 
 54          project, sourcefile, resourcetype, groupid, localid, platform = ookey 
 55          sourcefile = sourcefile.replace('\\','/') 
 56          if self.long_keys: 
 57              sourcebase = os.path.join(project, sourcefile) 
 58          else: 
 59              sourceparts = sourcefile.split('/') 
 60              sourcebase = "".join(sourceparts[-1:]) 
 61          if len(groupid) == 0 or len(localid) == 0: 
 62              fullid = groupid + localid 
 63          else: 
 64              fullid = groupid + "." + localid 
 65          if resourcetype: 
 66              fullid = fullid + "." + resourcetype 
 67          key = "%s#%s" % (sourcebase, fullid) 
 68          return oo.normalizefilename(key) 
  69   
 71          """makes an index of the oo keys that are used in the source file""" 
 72          self.index = {} 
 73          for ookey, theoo in self.o.ookeys.iteritems(): 
 74              sourcekey = self.makekey(ookey) 
 75              self.index[sourcekey] = theoo 
  76   
 83   
 85           
 86          locations = unit.getlocations() 
 87           
 88           
 89          for location in locations: 
 90              subkeypos = location.rfind('.') 
 91              subkey = location[subkeypos+1:] 
 92              key = location[:subkeypos] 
 93               
 94              key = key.replace(':', '#') 
 95               
 96              key = key.replace('\\', '/') 
 97              key = oo.normalizefilename(key) 
 98              if self.index.has_key(key): 
 99                   
100                  theoo = self.index[key]  
101                  self.applytranslation(key, subkey, theoo, unit) 
102              else: 
103                  print >> sys.stderr, "couldn't find key %s from po in %d keys" % (key, len(self.index)) 
104                  try: 
105                      sourceunitlines = str(unit) 
106                      if isinstance(sourceunitlines, unicode): 
107                          sourceunitlines = sourceunitlines.encode("utf-8") 
108                      print >> sys.stderr, sourceunitlines 
109                  except: 
110                      print >> sys.stderr, "error outputting source unit %r" % (str(unit),) 
 111   
113          """applies the translation from the source unit to the oo unit""" 
114          if not self.includefuzzy and unit.isfuzzy(): 
115              return 
116          makecopy = False 
117          if self.languages is None: 
118              part1 = theoo.lines[0] 
119              if len(theoo.lines) > 1: 
120                  part2 = theoo.lines[1] 
121              else: 
122                  makecopy = True 
123          else: 
124              part1 = theoo.languages[self.languages[0]] 
125              if self.languages[1] in theoo.languages: 
126                  part2 = theoo.languages[self.languages[1]] 
127              else: 
128                  makecopy = True 
129          if makecopy: 
130              part2 = oo.ooline(part1.getparts()) 
131          unquotedid = unit.source 
132          unquotedstr = unit.target 
133           
134          if len(unquotedstr.strip()) == 0: 
135              return 
136          if isinstance(unquotedstr, unicode): 
137              unquotedstr = unquotedstr.encode("UTF-8") 
138           
139          if len(unquotedstr) > 0: 
140              subkey = subkey.strip() 
141              setattr(part2, subkey, unquotedstr) 
142           
143          if self.timestamp_str: 
144              part2.timestamp = self.timestamp_str 
145          if self.languages: 
146              part2.languageid = self.languages[1] 
147          if makecopy: 
148              theoo.addline(part2) 
 149   
161      import stat 
162      return time.localtime(os.stat(filename)[stat.ST_MTIME]) 
 163   
166          """Returns whether or not to use unit in conversion. (filename is just for error reporting)""" 
167          if filteraction == "none": return True 
168          filterresult = self.filterunit(unit) 
169          if filterresult: 
170              if filterresult != autocorrect: 
171                  for filtername, filtermessage in filterresult.iteritems(): 
172                      location = unit.getlocations()[0] 
173                      if filtername in self.options.error: 
174                          print >> sys.stderr, "Error at %s::%s: %s" % (filename, location, filtermessage) 
175                          return not filteraction in ["exclude-all", "exclude-serious"] 
176                      if filtername in self.options.warning or self.options.alwayswarn: 
177                          print >> sys.stderr, "Warning at %s::%s: %s" % (filename, location, filtermessage) 
178                          return not filteraction in ["exclude-all"] 
179          return True 
 199 -def convertoo(inputfile, outputfile, templatefile, sourcelanguage=None, targetlanguage=None, timestamp=None, includefuzzy=False, multifilestyle="single", filteraction=None): 
 200      inputstore = factory.getobject(inputfile) 
201      inputstore.filename = getattr(inputfile, 'name', '') 
202      if not targetlanguage: 
203          raise ValueError("You must specify the target language") 
204      if not sourcelanguage: 
205          if targetlanguage.isdigit(): 
206              sourcelanguage = "01" 
207          else: 
208              sourcelanguage = "en-US" 
209      languages = (sourcelanguage, targetlanguage) 
210      if templatefile is None: 
211          raise ValueError("must have template file for oo files") 
212      else: 
213          convertor = reoo(templatefile, languages=languages, timestamp=timestamp, includefuzzy=includefuzzy, long_keys=multifilestyle != "single", filteraction=filteraction) 
214      outputstore = convertor.convertstore(inputstore) 
215       
216      outputfile.write(str(outputstore)) 
217      return True 
 218   
219 -def main(argv=None): 
 220      from translate.convert import convert 
221      formats = {("po", "oo"):("oo", convertoo), ("xlf", "oo"):("oo", convertoo)} 
222       
223      archiveformats = {(None, "output"): oo.oomultifile, (None, "template"): oo.oomultifile} 
224      parser = convert.ArchiveConvertOptionParser(formats, usetemplates=True, description=__doc__, archiveformats=archiveformats) 
225      parser.add_option("-l", "--language", dest="targetlanguage", default=None,  
226              help="set target language code (e.g. af-ZA) [required]", metavar="LANG") 
227      parser.add_option("", "--source-language", dest="sourcelanguage", default=None,  
228              help="set source language code (default en-US)", metavar="LANG") 
229      parser.add_option("-T", "--keeptimestamp", dest="timestamp", default=None, action="store_const", const=0, 
230              help="don't change the timestamps of the strings") 
231      parser.add_option("", "--nonrecursiveoutput", dest="allowrecursiveoutput", default=True, action="store_false", help="don't treat the output oo as a recursive store") 
232      parser.add_option("", "--nonrecursivetemplate", dest="allowrecursivetemplate", default=True, action="store_false", help="don't treat the template oo as a recursive store") 
233      parser.add_option("", "--filteraction", dest="filteraction", default="none", metavar="ACTION", 
234              help="action on pofilter failure: none (default), warn, exclude-serious, exclude-all") 
235      parser.add_fuzzy_option() 
236      parser.add_multifile_option() 
237      parser.passthrough.append("sourcelanguage") 
238      parser.passthrough.append("targetlanguage") 
239      parser.passthrough.append("timestamp") 
240      parser.passthrough.append("filteraction") 
241      parser.run(argv) 
 242   
243  if __name__ == '__main__': 
244      main() 
245