Export virt-convert strings for translation

Author: crobinso

setup.py

@@ -165,9 +165,12 @@ class install_lib(_install_lib):
     """ custom install_lib command to place locale location into library"""
 
     def run(self):
-        cmd = (("""sed -e "s,::LOCALEDIR::,%s," < virtinst/__init__.py > """ %\
-                locale) + "%s/virtinst/__init__.py" % builddir)
-        os.system(cmd)
+        for initfile in [ "virtinst/__init__.py", "virtconv/__init__.py" ]:
+            cmd =  "cat %s | " % initfile
+            cmd += """sed -e "s,::LOCALEDIR::,%s," > """ % locale
+            cmd += "%s/%s" % (builddir, initfile)
+            os.system(cmd)
+
         _install_lib.run(self)
 
 

tests/pylint-virtinst.sh

@@ -1,6 +1,6 @@
 #!/bin/sh
 
-FILES="setup.py tests/ virt-install virt-image virt-clone virt-convert virtinst/ virtconv virtconv/parsers/*.py"
+FILES="setup.py tests/ virt-install virt-image virt-clone virt-convert virtinst/ virtconv"
 
 # Exceptions: deliberately ignore these regex
 

virt-convert

@@ -25,76 +25,82 @@ import sys
 import os
 import logging
 import errno
+import gettext, locale
 from optparse import OptionGroup
 
 import virtinst.cli as cli
 from virtinst.cli import fail
 import virtinst.util as util
+import virtconv
 import virtconv.formats as formats
 import virtconv.vmcfg as vmcfg
 import virtconv.diskcfg as diskcfg
 
+locale.setlocale(locale.LC_ALL, '')
+gettext.bindtextdomain(virtconv.gettext_app, virtconv.gettext_dir)
+gettext.install(virtconv.gettext_app, virtconv.gettext_dir, unicode=1)
+
 def parse_args():
     """Parse and verify command line."""
     usage = "%prog [options] inputdir|input.vmx [outputdir|output.xml]"
     opts = cli.VirtOptionParser(usage=usage)
 
     cong = OptionGroup(opts, "Conversion Options")
     cong.add_option("-i", "--input-format", action="store",
-                    dest="input_format", help=("Input format, e.g. 'vmx'"))
+                    dest="input_format", help=_("Input format, e.g. 'vmx'"))
     cong.add_option("-o", "--output-format", action="store",
                     dest="output_format", default="virt-image",
-                    help=("Output format, e.g. 'virt-image'"))
+                    help=_("Output format, e.g. 'virt-image'"))
     cong.add_option("-D", "--disk-format", action="store",
-                    dest="disk_format", help=("Output disk format"))
+                    dest="disk_format", help=_("Output disk format"))
     opts.add_option_group(cong)
 
     virg = OptionGroup(opts, "Virtualization Type Options")
     virg.add_option("-v", "--hvm", action="store_true", dest="fullvirt",
-                    help=("This guest should be a fully virtualized guest"))
+                    help=_("This guest should be a fully virtualized guest"))
     virg.add_option("-p", "--paravirt", action="store_true", dest="paravirt",
-                    help=("This guest should be a paravirtualized guest"))
+                    help=_("This guest should be a paravirtualized guest"))
     opts.add_option_group(virg)
 
     cfgg = OptionGroup(opts, "Guest Configuration Options")
     cfgg.add_option("-a", "--arch", type="string", dest="arch",
                     default=util.get_default_arch(),
-                    help=("Machine Architecture Type (i686/x86_64/ppc)"))
+                    help=_("Machine Architecture Type (i686/x86_64/ppc)"))
     cfgg.add_option("", "--os-type", type="string", dest="os_type",
                     action="callback", callback=cli.check_before_store,
-                    help=("The OS type for fully virtualized guests, e.g. "
-                          "'linux', 'unix', 'windows'"))
+                    help=_("The OS type for fully virtualized guests, e.g. "
+                           "'linux', 'unix', 'windows'"))
     cfgg.add_option("", "--os-variant", type="string", dest="os_variant",
                     action="callback", callback=cli.check_before_store,
-                    help=("The OS variant for fully virtualized guests, e.g. "
-                          "'fedora6', 'rhel5', 'solaris10', 'win2k', 'vista'"))
+                    help=_("The OS variant for fully virtualized guests, e.g. "
+                           "'fedora6', 'rhel5', 'solaris10', 'win2k', 'vista'"))
     cfgg.add_option("", "--noapic", action="store_true", dest="noapic",
-                    help=("Disables APIC for fully virtualized guest "
-                          "(overrides value in os-type/os-variant db)"),
+                    help=_("Disables APIC for fully virtualized guest "
+                           "(overrides value in os-type/os-variant db)"),
                     default=False)
     cfgg.add_option("", "--noacpi", action="store_true", dest="noacpi",
-                    help=("Disables ACPI for fully virtualized guest "
-                          "(overrides value in os-type/os-variant db)"),
+                    help=_("Disables ACPI for fully virtualized guest "
+                           "(overrides value in os-type/os-variant db)"),
                     default=False)
     opts.add_option_group(cfgg)
 
     misc = OptionGroup(opts, "Miscellaneous Options")
     misc.add_option("-q", "--quiet", action="store_true", dest="quiet",
-                    help=("Don't be verbose"))
+                    help=_("Don't be verbose"))
     misc.add_option("-d", "--debug", action="store_true", dest="debug",
-                    help=("Print debugging information"))
+                    help=_("Print debugging information"))
     opts.add_option_group(misc)
 
 
     (options, args) = opts.parse_args()
     if len(args) < 1:
-        opts.error(("You need to provide an input VM definition"))
+        opts.error(_("You need to provide an input VM definition"))
     if len(args) > 2:
-        opts.error(("Too many arguments provided"))
-    
+        opts.error(_("Too many arguments provided"))
+
     if (options.disk_format and
         options.disk_format not in diskcfg.disk_formats()):
-        opts.error("Unknown output disk format \"%s\"" % options.disk_format)
+        opts.error(_("Unknown output disk format \"%s\"") % options.disk_format)
 
     if len(args) == 1:
         options.output_file = None
@@ -109,28 +115,28 @@ def parse_args():
         options.output_dir = os.path.dirname(os.path.realpath(args[1]))
 
     if options.output_format not in formats.formats():
-        opts.error(("Unknown output format \"%s\"" % options.output_format))
+        opts.error(_("Unknown output format \"%s\")" % options.output_format))
     if options.output_format not in formats.output_formats():
-        opts.error(("No output handler for format \"%s\""
+        opts.error(_("No output handler for format \"%s\")"
             % options.output_format))
 
     if not os.access(args[0], os.R_OK):
-        opts.error("Couldn't access input argument \"%s\"\n" % args[0])
+        opts.error(_("Couldn't access input argument \"%s\"\n") % args[0])
         sys.exit(1)
 
     if not options.input_format:
         try:
             (args[0], options.input_format) = formats.find_input(args[0])
         except StandardError, e:
-            opts.error("Couldn't determine input format for \"%s\": %s" % 
+            opts.error(_("Couldn't determine input format for \"%s\": %s") %
                 (args[0], e))
             sys.exit(1)
 
     if options.input_format not in formats.formats():
-        opts.error(("Unknown input format \"%s\"" % options.input_format))
+        opts.error(_("Unknown input format \"%s\")" % options.input_format))
     if options.input_format not in formats.input_formats():
-        opts.error(("No input handler for format \"%s\""
-            % options.input_format))
+        opts.error(_("No input handler for format \"%s\"")
+            % options.input_format)
 
     if os.path.isdir(args[0]):
         (options.input_file, ignore) = formats.find_input(args[0],
@@ -164,8 +170,8 @@ def cleanup(msg, options, vmdef, paths):
             elif os.path.isfile(path):
                 os.remove(path)
     except OSError, e:
-        fail("Couldn't clean up output directory \"%s\": %s" %
-             (options.output_dir, e.strerror))
+        fail(_("Couldn't clean up output directory \"%s\": %s") %
+               (options.output_dir, e.strerror))
 
     sys.exit(1)
 
@@ -181,10 +187,10 @@ def main():
     try:
         vmdef = inp.import_file(options.input_file)
     except IOError, e:
-        fail("Couldn't import file \"%s\": %s" %
+        fail(_("Couldn't import file \"%s\": %s") %
             (options.input_file, e.strerror))
     except Exception, e:
-        fail("Couldn't import file \"%s\": %s" % (options.input_file, e))
+        fail(_("Couldn't import file \"%s\": %s") % (options.input_file, e))
 
     if options.paravirt:
         vmdef.type = vmcfg.VM_TYPE_PV
@@ -221,8 +227,8 @@ def main():
     logging.debug("output_file: %s" % options.output_file)
     logging.debug("output_dir: %s" % options.input_dir)
 
-    verbose(options, "Generating output in \"%s\" format to %s/" %
-        (options.output_format, options.output_dir))
+    verbose(options, _("Generating output in '%(format)s' format to %(dir)s/") %
+        {"format": options.output_format, "dir": options.output_dir})
 
 
     try:
@@ -240,34 +246,35 @@ def main():
                 format = "raw"
 
             if d.path and format != "none":
-                verbose(options, "Converting disk \"%s\" to type %s..." %
-                    (d.path, format))
+                verbose(options, _("Converting disk '%(path)s' to type "
+                                   "%(format)s...") % {"path": d.path,
+                                                       "format": format})
 
             d.convert(options.input_dir, options.output_dir, format)
 
     except OSError, e:
-        cleanup("Couldn't convert disks: %s" % e.strerror,
+        cleanup(_("Couldn't convert disks: %s") % e.strerror,
             options, vmdef, clean)
     except RuntimeError, e:
-        cleanup("Couldn't convert disks: %s" % e, options, vmdef, clean)
+        cleanup(_("Couldn't convert disks: %s") % e, options, vmdef, clean)
 
     try:
         clean += [ options.output_file ]
         outp.export_file(vmdef, options.output_file)
     except ValueError, e:
-        cleanup("Couldn't export to file \"%s\": %s" %
+        cleanup(_("Couldn't export to file \"%s\": %s") %
             (options.output_file, e), options, vmdef, clean)
 
     verbose(options, "Done.")
 
-    
+
 if __name__ == "__main__":
     try:
         main()
     except SystemExit, sys_e:
         sys.exit(sys_e.code)
     except KeyboardInterrupt:
-        print >> sys.stderr, "Aborted at user request"
+        print >> sys.stderr, _("Aborted at user request")
     except Exception, main_e:
         logging.exception(main_e)
         sys.exit(1)

virtconv/__init__.py

@@ -21,6 +21,15 @@
 import pkgutil
 import imp
 import os
+import gettext
+
+gettext_dir = "::LOCALEDIR::"
+gettext_app = "virtinst"
+
+gettext.bindtextdomain(gettext_app, gettext_dir)
+
+def _gettext(msg):
+    return gettext.dgettext(gettext_app, msg)
 
 parsers_path = [os.path.join(__path__[0], "parsers/")]
 

virtconv/diskcfg.py

@@ -25,6 +25,8 @@
 import os
 import re
 
+from virtconv import _gettext as _
+
 DISK_FORMAT_NONE = 0
 DISK_FORMAT_RAW = 1
 DISK_FORMAT_VMDK = 2
@@ -237,7 +239,7 @@ def convert(self, indir, outdir, output_format):
             out_format == DISK_FORMAT_VDISK or
             out_format == DISK_FORMAT_RAW or
             out_format == DISK_FORMAT_VMDK):
-            raise NotImplementedError("Cannot convert to disk format %s" %
+            raise NotImplementedError(_("Cannot convert to disk format %s") %
                 output_format)
 
         indir = os.path.normpath(os.path.abspath(indir))
@@ -250,8 +252,8 @@ def convert(self, indir, outdir, output_format):
             return
 
         if os.path.isabs(self.path):
-            raise NotImplementedError("Cannot convert disk with absolute"
-                "path %s" % self.path)
+            raise NotImplementedError(_("Cannot convert disk with absolute"
+                " path %s") % self.path)
 
         if input_in_outdir:
             indir = outdir

virtconv/formats.py

@@ -20,6 +20,8 @@
 
 import os
 
+from virtconv import _gettext as _
+
 _parsers = [ ]
 
 class parser(object):
@@ -136,4 +138,4 @@ def find_input(path, format = None):
                 if p.identify_file(os.path.join(path, cfgfile)):
                     return (os.path.join(path, cfgfile), p.name)
 
-    raise StandardError("unknown format")
+    raise StandardError(_("Unknown format"))

virtconv/parsers/virtimage.py

@@ -18,6 +18,7 @@
 # MA 02110-1301 USA.
 #
 
+from virtconv import _gettext as _
 import virtconv.formats as formats
 import virtconv.vmcfg as vmcfg
 import virtconv.diskcfg as diskcfg
@@ -207,14 +208,15 @@ def import_file(input_file):
         vm = vmcfg.vm()
         try:
             config  = ImageParser.parse_file(input_file)
-        except Exception, e:        
-            raise ValueError("Couldn't import file '%s': %s" % (input_file, e))
+        except Exception, e:
+            raise ValueError(_("Couldn't import file '%s': %s") %
+                             (input_file, e))
 
         domain = config.domain
         boot = domain.boots[0]
 
         if not config.name:
-            raise ValueError("No Name defined in '%s'" % input_file)
+            raise ValueError(_("No Name defined in '%s'") % input_file)
         vm.name = config.name
         vm.memory = int(config.domain.memory / 1024)
         if config.descr:
@@ -233,14 +235,14 @@ def import_file(input_file):
                 format = diskcfg.DISK_FORMAT_VMDK
 
             if format is None:
-                raise ValueError("Unable to determine disk format")
+                raise ValueError(_("Unable to determine disk format"))
             devid = (bus, nr_disk)
             vm.disks[devid] = diskcfg.disk(bus = bus,
                 type = diskcfg.DISK_TYPE_DISK)
             vm.disks[devid].format = format
             vm.disks[devid].path = disk.file
             nr_disk = nr_disk + 1
-           
+
         nics = domain.interface
         nic_idx = 0
         while nic_idx in range(0, nics):
@@ -260,7 +262,7 @@ def export(vm):
         """
 
         if not vm.memory:
-            raise ValueError("VM must have a memory setting")
+            raise ValueError(_("VM must have a memory setting"))
 
         # xend wants the name to match r'^[A-Za-z0-9_\-\.\:\/\+]+$', and
         # the schema agrees.

virtconv/parsers/vmx.py

@@ -18,6 +18,7 @@
 # MA 02110-1301 USA.
 #
 
+from virtconv import _gettext as _
 import virtconv.formats as formats
 import virtconv.vmcfg as vmcfg
 import virtconv.diskcfg as diskcfg
@@ -212,7 +213,7 @@ def import_file(input_file):
                 if key.startswith("ethernet"):
                     parse_netdev_entry(vm, key, value)
             except:
-                raise Exception("Syntax error at line %d: %s" %
+                raise Exception(_("Syntax error at line %d: %s") %
                     (line_nr + 1, line.strip()))
 
         for devid, disk in vm.disks.iteritems():
@@ -226,7 +227,8 @@ def import_file(input_file):
                 vm.disks[devid].path = None
 
         if not config.get("displayname"):
-            raise ValueError("No displayName defined in \"%s\"" % input_file)
+            raise ValueError(_("No displayName defined in \"%s\"") %
+                             input_file)
         vm.name = config.get("displayname")
 
         vm.memory = config.get("memsize")