1

#! /usr/bin/env python

     2

# -*- coding: iso-8859-1 -*-

     3

# 

     4

#   PYTHON MODULE:     MKI18N.PY

     5

#                      =========

     6

# 

     7

#   Abstract:         Make Internationalization (i18n) files for an application.

     8

# 

     9

#   Copyright Pierre Rouleau. 2003. Released to public domain.

    10

# 

    11

#   Last update: Saturday, November 8, 2003. @ 15:55:18.

    12

# 

    13

#   File: ROUP2003N01::C:/dev/python/mki18n.py

    14

# 

    15

#   RCS $Header: //software/official/MKS/MKS_SI/TV_NT/dev/Python/rcs/mki18n.py 1.5 2003/11/05 19:40:04 PRouleau Exp $

    16

# 

    17

#   Update history:

    18

# 

    19

#   - File created: Saturday, June 7, 2003. by Pierre Rouleau

    20

#   - 10/06/03 rcs : RCS Revision 1.1  2003/06/10 10:06:12  PRouleau

    21

#   - 10/06/03 rcs : RCS Initial revision

    22

#   - 23/08/03 rcs : RCS Revision 1.2  2003/06/10 10:54:27  PRouleau

    23

#   - 23/08/03 P.R.: [code:fix] : The strings encoded in this file are encode in iso-8859-1 format.  Added the encoding

    24

#                    notification to Python to comply with Python's 2.3 PEP 263.

    25

#   - 23/08/03 P.R.: [feature:new] : Added the '-e' switch which is used to force the creation of the empty English .mo file.

    26

#   - 22/10/03 P.R.: [code] : incorporated utility functions in here to make script self sufficient.

    27

#   - 05/11/03 rcs : RCS Revision 1.4  2003/10/22 06:39:31  PRouleau

    28

#   - 05/11/03 P.R.: [code:fix] : included the unixpath() in this file.

    29

#   - 08/11/03 rcs : RCS Revision 1.5  2003/11/05 19:40:04  PRouleau

    30

# 

    31

#   RCS $Log: $

    32

# 

    33

# 

    34

# -----------------------------------------------------------------------------

    35

"""                                

    36

mki18n allows you to internationalize your software.  You can use it to 

    37

create the GNU .po files (Portable Object) and the compiled .mo files

    38

(Machine Object).

    39

    40

mki18n module can be used from the command line or from within a script (see 

    41

the Usage at the end of this page).

    42

    43

    Table of Contents

    44

    -----------------

    45

    46

    makePO()             -- Build the Portable Object file for the application --

    47

    catPO()              -- Concatenate one or several PO files with the application domain files. --

    48

    makeMO()             -- Compile the Portable Object files into the Machine Object stored in the right location. --

    49

    printUsage           -- Displays how to use this script from the command line --

    50

    51

    Scriptexecution      -- Runs when invoked from the command line --

    52

    53

    54

NOTE:  this module uses GNU gettext utilities.

    55

    56

You can get the gettext tools from the following sites:

    57

    58

   - `GNU FTP site for gettetx`_ where several versions (0.10.40, 0.11.2, 0.11.5 and 0.12.1) are available.

    59

     Note  that you need to use `GNU libiconv`_ to use this. Get it from the `GNU

    60

     libiconv  ftp site`_ and get version 1.9.1 or later. Get the Windows .ZIP

    61

     files and install the packages inside c:/gnu. All binaries will be stored

    62

     inside  c:/gnu/bin.  Just  put c:/gnu/bin inside your PATH. You will need

    63

     the following files: 

    64

    65

      - `gettext-runtime-0.12.1.bin.woe32.zip`_ 

    66

      - `gettext-tools-0.12.1.bin.woe32.zip`_

    67

      - `libiconv-1.9.1.bin.woe32.zip`_ 

    68

    69

    70

.. _GNU libiconv:                            http://www.gnu.org/software/libiconv/

    71

.. _GNU libiconv ftp site:                   http://www.ibiblio.org/pub/gnu/libiconv/

    72

.. _gettext-runtime-0.12.1.bin.woe32.zip:    ftp://ftp.gnu.org/gnu/gettext/gettext-runtime-0.12.1.bin.woe32.zip           

    73

.. _gettext-tools-0.12.1.bin.woe32.zip:      ftp://ftp.gnu.org/gnu/gettext/gettext-tools-0.12.1.bin.woe32.zip 

    74

.. _libiconv-1.9.1.bin.woe32.zip:            http://www.ibiblio.org/pub/gnu/libiconv/libiconv-1.9.1.bin.woe32.zip

    75

    76

"""

    77

# -----------------------------------------------------------------------------

    78

# Module Import

    79

# -------------

    80

# 

    81

import os

    82

import sys

    83

import wx

    84

# -----------------------------------------------------------------------------

    85

# Global variables

    86

# ----------------

    87

#

    88

    89

__author__ = "Pierre Rouleau"

    90

__version__= "$Revision: 1.5 $"

    91

    92

# -----------------------------------------------------------------------------

    93

    94

def getlanguageDict():

    95

    languageDict = {}

    96

    97

    for lang in [x for x in dir(wx) if x.startswith("LANGUAGE")]:

    98

        i = wx.Locale(wx.LANGUAGE_DEFAULT).GetLanguageInfo(getattr(wx, lang))

    99

        if i:

   100

            languageDict[i.CanonicalName] = i.Description

   101

   102

    return languageDict

   103

   104

# -----------------------------------------------------------------------------

   105

# m a k e P O ( )         -- Build the Portable Object file for the application --

   106

# ^^^^^^^^^^^^^^^

   107

#

   108

def makePO(applicationDirectoryPath,  applicationDomain=None, verbose=0) :

   109

    """Build the Portable Object Template file for the application.

   110

   111

    makePO builds the .pot file for the application stored inside 

   112

    a specified directory by running xgettext for all application source 

   113

    files.  It finds the name of all files by looking for a file called 'app.fil'. 

   114

    If this file does not exists, makePo raises an IOError exception.

   115

    By default the application domain (the application

   116

    name) is the same as the directory name but it can be overridden by the

   117

    'applicationDomain' argument.

   118

   119

    makePO always creates a new file called messages.pot.  If it finds files 

   120

    of the form app_xx.po where 'app' is the application name and 'xx' is one 

   121

    of the ISO 639 two-letter language codes, makePO resynchronizes those 

   122

    files with the latest extracted strings (now contained in messages.pot). 

   123

    This process updates all line location number in the language-specific

   124

    .po files and may also create new entries for translation (or comment out 

   125

    some).  The .po file is not changed, instead a new file is created with 

   126

    the .new extension appended to the name of the .po file.

   127

   128

    By default the function does not display what it is doing.  Set the 

   129

    verbose argument to 1 to force it to print its commands.

   130

    """

   131

   132

    if applicationDomain is None:

   133

        applicationName = fileBaseOf(applicationDirectoryPath,withPath=0)

   134

    else:

   135

        applicationName = applicationDomain

   136

    currentDir = os.getcwd()

   137

    os.chdir(applicationDirectoryPath)                    

   138

    if not os.path.exists('app.fil'):

   139

        raise IOError(2,'No module file: app.fil')

   140

   141

    # Steps:                                  

   142

    #  Use xgettext to parse all application modules

   143

    #  The following switches are used:

   144

    #  

   145

    #   -s                          : sort output by string content (easier to use when we need to merge several .po files)

   146

    #   --files-from=app.fil        : The list of files is taken from the file: app.fil

   147

    #   --output=                   : specifies the name of the output file (using a .pot extension)

   148

    cmd = 'xgettext -s --no-wrap --language=Python --files-from=app.fil --output=messages.pot'

   149

    if verbose: print cmd

   150

    os.system(cmd)                                                

   151

   152

    languageDict = getlanguageDict()

   153

   154

    for langCode in languageDict.keys():

   155

        if langCode == 'en':

   156

            pass

   157

        else:

   158

            langPOfileName = "%s_%s.po" % (applicationName , langCode)

   159

            if os.path.exists(langPOfileName):

   160

                cmd = 'msgmerge -s --no-wrap "%s" messages.pot > "%s.new"' % (langPOfileName, langPOfileName)

   161

                if verbose: print cmd

   162

                os.system(cmd)

   163

    os.chdir(currentDir)

   164

   165

# -----------------------------------------------------------------------------

   166

# c a t P O ( )         -- Concatenate one or several PO files with the application domain files. --

   167

# ^^^^^^^^^^^^^

   168

#

   169

def catPO(applicationDirectoryPath, listOf_extraPo, applicationDomain=None, targetDir=None, verbose=0) :

   170

    """Concatenate one or several PO files with the application domain files.

   171

    """

   172

   173

    if applicationDomain is None:

   174

        applicationName = fileBaseOf(applicationDirectoryPath,withPath=0)

   175

    else:

   176

        applicationName = applicationDomain

   177

    currentDir = os.getcwd()

   178

    os.chdir(applicationDirectoryPath)

   179

   180

    languageDict = getlanguageDict()

   181

   182

    for langCode in languageDict.keys():

   183

        if langCode == 'en':

   184

            pass

   185

        else:

   186

            langPOfileName = "%s_%s.po" % (applicationName , langCode)

   187

            if os.path.exists(langPOfileName):

   188

                fileList = ''

   189

                for fileName in listOf_extraPo:

   190

                    fileList += ("%s_%s.po " % (fileName,langCode))

   191

                cmd = "msgcat -s --no-wrap %s %s > %s.cat" % (langPOfileName, fileList, langPOfileName)

   192

                if verbose: print cmd

   193

                os.system(cmd)

   194

                if targetDir is None:

   195

                    pass

   196

                else:

   197

                    mo_targetDir = "%s/%s/LC_MESSAGES" % (targetDir,langCode)

   198

                    cmd = "msgfmt --output-file=%s/%s.mo %s_%s.po.cat" % (mo_targetDir,applicationName,applicationName,langCode)

   199

                    if verbose: print cmd

   200

                    os.system(cmd)

   201

    os.chdir(currentDir)

   202

   203

# -----------------------------------------------------------------------------

   204

# m a k e M O ( )         -- Compile the Portable Object files into the Machine Object stored in the right location. --

   205

# ^^^^^^^^^^^^^^^

   206

# 

   207

def makeMO(applicationDirectoryPath,targetDir='./locale',applicationDomain=None, verbose=0, forceEnglish=0) :

   208

    """Compile the Portable Object files into the Machine Object stored in the right location.

   209

   210

    makeMO converts all translated language-specific PO files located inside 

   211

    the  application directory into the binary .MO files stored inside the 

   212

    LC_MESSAGES sub-directory for the found locale files.

   213

   214

    makeMO searches for all files that have a name of the form 'app_xx.po' 

   215

    inside the application directory specified by the first argument.  The 

   216

    'app' is the application domain name (that can be specified by the 

   217

    applicationDomain argument or is taken from the directory name). The 'xx' 

   218

    corresponds to one of the ISO 639 two-letter language codes.

   219

   220

    makeMo stores the resulting files inside a sub-directory of `targetDir`

   221

    called xx/LC_MESSAGES where 'xx' corresponds to the 2-letter language

   222

    code.

   223

    """

   224

    if targetDir is None:

   225

        targetDir = './locale'

   226

    if verbose:

   227

        print "Target directory for .mo files is: %s" % targetDir

   228

   229

    if applicationDomain is None:

   230

        applicationName = fileBaseOf(applicationDirectoryPath,withPath=0)

   231

    else:

   232

        applicationName = applicationDomain

   233

    currentDir = os.getcwd()

   234

    os.chdir(applicationDirectoryPath)

   235

   236

    languageDict = getlanguageDict()

   237

   238

    for langCode in languageDict.keys():

   239

        if (langCode == 'en') and (forceEnglish==0):

   240

            pass

   241

        else:

   242

            langPOfileName = "%s_%s.po" % (applicationName , langCode)

   243

            if os.path.exists(langPOfileName):

   244

                mo_targetDir = "%s/%s/LC_MESSAGES" % (targetDir,langCode)

   245

                if not os.path.exists(mo_targetDir):

   246

                    mkdir(mo_targetDir)

   247

                cmd = 'msgfmt --output-file="%s/%s.mo" "%s_%s.po"' % (mo_targetDir,applicationName,applicationName,langCode)

   248

                if verbose: print cmd

   249

                os.system(cmd)

   250

    os.chdir(currentDir)

   251

   252

# -----------------------------------------------------------------------------

   253

# p r i n t U s a g e         -- Displays how to use this script from the command line --

   254

# ^^^^^^^^^^^^^^^^^^^

   255

#

   256

def printUsage(errorMsg=None) :

   257

    """Displays how to use this script from the command line."""

   258

    print """

   259

    ##################################################################################

   260

    #   mki18n :   Make internationalization files.                                  #

   261

    #              Uses the GNU gettext system to create PO (Portable Object) files  #

   262

    #              from source code, coimpile PO into MO (Machine Object) files.     #

   263

    #              Supports C,C++,Python source files.                               #

   264

    #                                                                                #

   265

    #   Usage: mki18n {OPTION} [appDirPath]                                          #

   266

    #                                                                                #

   267

    #   Options:                                                                     #

   268

    #     -e               : When -m is used, forces English .mo file creation       #

   269

    #     -h               : prints this help                                        #

   270

    #     -m               : make MO from existing PO files                          #

   271

    #     -p               : make PO, update PO files: Creates a new messages.pot    #

   272

    #                        file. Creates a dom_xx.po.new for every existing        #

   273

    #                        language specific .po file. ('xx' stands for the ISO639 #

   274

    #                        two-letter language code and 'dom' stands for the       #

   275

    #                        application domain name).  mki18n requires that you     #

   276

    #                        write a 'app.fil' file  which contains the list of all  #

   277

    #                        source code to parse.                                   #

   278

    #     -v               : verbose (prints comments while running)                 #

   279

    #     --domain=appName : specifies the application domain name.  By default      #

   280

    #                        the directory name is used.                             #

   281

    #     --moTarget=dir : specifies the directory where .mo files are stored.       #

   282

    #                      If not specified, the target is './locale'                #

   283

    #                                                                                #

   284

    #   You must specify one of the -p or -m option to perform the work.  You can    #

   285

    #   specify the path of the target application.  If you leave it out mki18n      #

   286

    #   will use the current directory as the application main directory.            #        

   287

    #                                                                                #

   288

    ##################################################################################"""

   289

    if errorMsg:

   290

        print "\n   ERROR: %s" % errorMsg

   291

   292

# -----------------------------------------------------------------------------

   293

# f i l e B a s e O f ( )         -- Return base name of filename --

   294

# ^^^^^^^^^^^^^^^^^^^^^^^

   295

# 

   296

def fileBaseOf(filename,withPath=0) :

   297

   """fileBaseOf(filename,withPath) ---> string

   298

   299

   Return base name of filename.  The returned string never includes the extension.

   300

   Use os.path.basename() to return the basename with the extension.  The 

   301

   second argument is optional.  If specified and if set to 'true' (non zero) 

   302

   the string returned contains the full path of the file name.  Otherwise the 

   303

   path is excluded.

   304

   305

   [Example]

   306

   >>> fn = 'd:/dev/telepath/tvapp/code/test.html'

   307

   >>> fileBaseOf(fn)

   308

   'test'

   309

   >>> fileBaseOf(fn)

   310

   'test'

   311

   >>> fileBaseOf(fn,1)

   312

   'd:/dev/telepath/tvapp/code/test'

   313

   >>> fileBaseOf(fn,0)

   314

   'test'

   315

   >>> fn = 'abcdef'

   316

   >>> fileBaseOf(fn)

   317

   'abcdef'

   318

   >>> fileBaseOf(fn,1)

   319

   'abcdef'

   320

   >>> fn = "abcdef."

   321

   >>> fileBaseOf(fn)

   322

   'abcdef'

   323

   >>> fileBaseOf(fn,1)

   324

   'abcdef'

   325

   """            

   326

   pos = filename.rfind('.')             

   327

   if pos > 0:

   328

      filename = filename[:pos]

   329

   if withPath:

   330

      return filename

   331

   else:

   332

      return os.path.basename(filename)

   333

# -----------------------------------------------------------------------------

   334

# m k d i r ( )         -- Create a directory (and possibly the entire tree) --

   335

# ^^^^^^^^^^^^^

   336

# 

   337

def mkdir(directory) :

   338

   """Create a directory (and possibly the entire tree).

   339

   340

   The os.mkdir() will fail to create a directory if one of the

   341

   directory in the specified path does not exist.  mkdir()

   342

   solves this problem.  It creates every intermediate directory

   343

   required to create the final path. Under Unix, the function 

   344

   only supports forward slash separator, but under Windows and MacOS

   345

   the function supports the forward slash and the OS separator (backslash

   346

   under windows).

   347

   """ 

   348

   349

   # translate the path separators

   350

   directory = unixpath(directory)

   351

   # build a list of all directory elements

   352

   aList = filter(lambda x: len(x)>0, directory.split('/'))

   353

   theLen = len(aList)                     

   354

   # if the first element is a Windows-style disk drive

   355

   # concatenate it with the first directory

   356

   if aList[0].endswith(':'):

   357

      if theLen > 1:

   358

         aList[1] = aList[0] + '/' + aList[1]

   359

         del aList[0]      

   360

         theLen -= 1         

   361

   # if the original directory starts at root,

   362

   # make sure the first element of the list 

   363

   # starts at root too

   364

   if directory[0] == '/':     

   365

      aList[0] = '/' + aList[0]

   366

   # Now iterate through the list, check if the 

   367

   # directory exists and if not create it

   368

   theDir = ''

   369

   for i in range(theLen):

   370

      theDir += aList[i]

   371

      if not os.path.exists(theDir):

   372

         os.mkdir(theDir)

   373

      theDir += '/'   

   374

   375

# -----------------------------------------------------------------------------

   376

# u n i x p a t h ( )         -- Return a path name that contains Unix separator. --

   377

# ^^^^^^^^^^^^^^^^^^^

   378

# 

   379

def unixpath(thePath) :

   380

   r"""Return a path name that contains Unix separator.

   381

   382

   [Example]

   383

   >>> unixpath(r"d:\test")

   384

   'd:/test'

   385

   >>> unixpath("d:/test/file.txt")

   386

   'd:/test/file.txt'

   387

   >>> 

   388

   """

   389

   thePath = os.path.normpath(thePath)

   390

   if os.sep == '/':

   391

      return thePath

   392

   else:

   393

      return thePath.replace(os.sep,'/')

   394

   395

# ----------------------------------------------------------------------------- 

   396

   397

# S c r i p t   e x e c u t i o n               -- Runs when invoked from the command line --

   398

# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

   399

# 

   400

if __name__ == "__main__":

   401

    import getopt     # command line parsing

   402

    argc = len(sys.argv)

   403

    if argc == 1:

   404

        printUsage('Missing argument: specify at least one of -m or -p (or both).')

   405

        sys.exit(1)

   406

    # If there is some arguments, parse the command line

   407

    validOptions     = "ehmpv"

   408

    validLongOptions = ['domain=', 'moTarget=']             

   409

    option = {}

   410

    option['forceEnglish'] = 0

   411

    option['mo'] = 0

   412

    option['po'] = 0        

   413

    option['verbose'] = 0

   414

    option['domain'] = None

   415

    option['moTarget'] = None

   416

    try:

   417

        optionList,pargs = getopt.getopt(sys.argv[1:],validOptions,validLongOptions)

   418

    except getopt.GetoptError, e:

   419

        printUsage(e[0])

   420

        sys.exit(1)       

   421

    for (opt,val) in optionList:

   422

        if  (opt == '-h'):    

   423

            printUsage()

   424

            sys.exit(0) 

   425

        elif (opt == '-e'):         option['forceEnglish'] = 1

   426

        elif (opt == '-m'):         option['mo'] = 1

   427

        elif (opt == '-p'):         option['po'] = 1

   428

        elif (opt == '-v'):         option['verbose'] = 1

   429

        elif (opt == '--domain'):   option['domain'] = val

   430

        elif (opt == '--moTarget'): option['moTarget'] = val

   431

    if len(pargs) == 0:

   432

        appDirPath = os.getcwd()

   433

        if option['verbose']:

   434

            print "No project directory given. Using current one:  %s" % appDirPath

   435

    elif len(pargs) == 1:

   436

        appDirPath = pargs[0]

   437

    else:

   438

        printUsage('Too many arguments (%u).  Use double quotes if you have space in directory name' % len(pargs))

   439

        sys.exit(1)

   440

    if option['domain'] is None:

   441

        # If no domain specified, use the name of the target directory

   442

        option['domain'] = fileBaseOf(appDirPath)

   443

    if option['verbose']:

   444

        print "Application domain used is: '%s'" % option['domain']

   445

    if option['po']:

   446

        try:

   447

            makePO(appDirPath,option['domain'],option['verbose'])

   448

        except IOError, e:

   449

            printUsage(e[1] + '\n   You must write a file app.fil that contains the list of all files to parse.')

   450

    if option['mo']:

   451

        makeMO(appDirPath,option['moTarget'],option['domain'],option['verbose'],option['forceEnglish'])

   452

    sys.exit(1)            

   453

   454

   455

# -----------------------------------------------------------------------------