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

from __future__ import print_function

    82

import os

    83

import sys

    84

import re

    85

import wx

    86

    87

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

    88

# Global variables

    89

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

    90

#

    91

    92

__author__ = "Pierre Rouleau"

    93

__version__ = "$Revision: 1.5 $"

    94

    95

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

    96

    97

    98

def getlanguageDict():

    99

    languageDict = {}

   100

   101

    if wx.VERSION >= (3, 0, 0):

   102

        _app = wx.App()

   103

    else:

   104

        _app = wx.PySimpleApp()

   105

   106

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

   107

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

   108

        if i:

   109

            languageDict[i.CanonicalName] = i.Description

   110

   111

    return languageDict

   112

   113

   114

def verbosePrint(verbose, str):

   115

    if verbose:

   116

        print(str)

   117

   118

   119

def processCustomFiles(filein, fileout, regexp, prefix=''):

   120

    appfil_file = open(filein, 'r')

   121

    messages_file = open(fileout, 'r')

   122

    messages = messages_file.read()

   123

    messages_file.close()

   124

    messages_file = open(fileout, 'a')

   125

    messages_file.write('\n')

   126

    messages_file.write('#: %s\n' % prefix)

   127

    messages_file.write('\n')

   128

   129

    words_found = {}

   130

    for filepath in appfil_file.xreadlines():

   131

        code_file = open(filepath.strip(), 'r')

   132

        for match in regexp.finditer(code_file.read()):

   133

            word = match.group(1)

   134

            if not words_found.get(word, False) and messages.find("msgid \"%s\"\nmsgstr \"\"" % word) == -1:

   135

                words_found[word] = True

   136

                messages_file.write('\n')

   137

                messages_file.write("msgid \"%s\"\n" % word)

   138

                messages_file.write("msgstr \"\"\n")

   139

        code_file.close()

   140

   141

    messages_file.close()

   142

    appfil_file.close()

   143

   144

   145

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

   146

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

   147

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

   148

#

   149

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

   150

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

   151

   152

    makePO builds the .pot file for the application stored inside

   153

    a specified directory by running xgettext for all application source

   154

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

   155

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

   156

    By default the application domain (the application

   157

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

   158

    'applicationDomain' argument.

   159

   160

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

   161

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

   162

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

   163

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

   164

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

   165

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

   166

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

   167

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

   168

   169

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

   170

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

   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

    filelist = 'app.fil'

   180

    if not os.path.exists(filelist):

   181

        raise IOError(2, 'No module file: ' % filelist)

   182

   183

    fileout = 'messages.pot'

   184

    # Steps:

   185

    #  Use xgettext to parse all application modules

   186

    #  The following switches are used:

   187

    #

   188

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

   189

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

   190

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

   191

    cmd = 'xgettext -s --no-wrap --language=Python --files-from=' + filelist + ' --output=' + fileout + ' --package-name ' + applicationName

   192

    verbosePrint(verbose, cmd)

   193

    os.system(cmd)

   194

   195

    XSD_STRING_MODEL = re.compile("<xsd\:(?:element|attribute) name=\"([^\"]*)\"[^\>]*\>")

   196

    processCustomFiles(filelist, fileout, XSD_STRING_MODEL, 'Extra XSD strings')

   197

   198

    XML_TC6_STRING_MODEL = re.compile("<documentation>\s*<xhtml\:p><!\[CDATA\[([^\]]*)\]\]></xhtml\:p>\s*</documentation>", re.MULTILINE | re.DOTALL)

   199

    processCustomFiles(filelist, fileout, XML_TC6_STRING_MODEL, 'Extra TC6 documentation strings')

   200

   201

    # generate messages.po

   202

    cmd = 'msginit --no-wrap --no-translator -i %s -l en_US.UTF-8 -o messages.po' % (fileout)

   203

    verbosePrint(verbose, cmd)

   204

    os.system(cmd)

   205

   206

    languageDict = getlanguageDict()

   207

   208

    for langCode in languageDict.keys():

   209

        if langCode == 'en':

   210

            pass

   211

        else:

   212

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

   213

            if os.path.exists(langPOfileName):

   214

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

   215

                verbosePrint(verbose, cmd)

   216

                os.system(cmd)

   217

    os.chdir(currentDir)

   218

   219

   220

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

   221

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

   222

    """

   223

   224

    if applicationDomain is None:

   225

        applicationName = fileBaseOf(applicationDirectoryPath, withPath=0)

   226

    else:

   227

        applicationName = applicationDomain

   228

    currentDir = os.getcwd()

   229

    os.chdir(applicationDirectoryPath)

   230

   231

    languageDict = getlanguageDict()

   232

   233

    for langCode in languageDict.keys():

   234

        if langCode == 'en':

   235

            pass

   236

        else:

   237

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

   238

            if os.path.exists(langPOfileName):

   239

                fileList = ''

   240

                for fileName in listOf_extraPo:

   241

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

   242

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

   243

                verbosePrint(verbose, cmd)

   244

                os.system(cmd)

   245

                if targetDir is None:

   246

                    pass

   247

                else:

   248

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

   249

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

   250

                    verbosePrint(verbose, cmd)

   251

                    os.system(cmd)

   252

    os.chdir(currentDir)

   253

   254

   255

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

   256

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

   257

   258

    makeMO converts all translated language-specific PO files located inside

   259

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

   260

    LC_MESSAGES sub-directory for the found locale files.

   261

   262

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

   263

    inside the application directory specified by the first argument.  The

   264

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

   265

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

   266

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

   267

   268

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

   269

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

   270

    code.

   271

    """

   272

   273

    if targetDir is None:

   274

        targetDir = './locale'

   275

   276

    verbosePrint(verbose, "Target directory for .mo files is: %s" % targetDir)

   277

   278

    if applicationDomain is None:

   279

        applicationName = fileBaseOf(applicationDirectoryPath, withPath=0)

   280

    else:

   281

        applicationName = applicationDomain

   282

    currentDir = os.getcwd()

   283

    os.chdir(applicationDirectoryPath)

   284

   285

    languageDict = getlanguageDict()

   286

   287

    for langCode in languageDict.keys():

   288

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

   289

            pass

   290

        else:

   291

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

   292

            if os.path.exists(langPOfileName):

   293

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

   294

                if not os.path.exists(mo_targetDir):

   295

                    mkdir(mo_targetDir)

   296

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

   297

                verbosePrint(verbose, cmd)

   298

                os.system(cmd)

   299

    os.chdir(currentDir)

   300

   301

   302

def printUsage(errorMsg=None):

   303

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

   304

    print("""

   305

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

   306

    #   mki18n :   Make internationalization files.                                  #

   307

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

   308

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

   309

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

   310

    #                                                                                #

   311

    #   Usage: mki18n {OPTION} [appDirPath]                                          #

   312

    #                                                                                #

   313

    #   Options:                                                                     #

   314

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

   315

    #     -h               : prints this help                                        #

   316

    #     -m               : make MO from existing PO files                          #

   317

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

   318

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

   319

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

   320

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

   321

    #                        application domain name).  mki18n requires that you     #

   322

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

   323

    #                        source code to parse.                                   #

   324

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

   325

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

   326

    #                        the directory name is used.                             #

   327

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

   328

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

   329

    #                                                                                #

   330

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

   331

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

   332

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

   333

    #                                                                                #

   334

    ##################################################################################""")

   335

    if errorMsg:

   336

        print("\n   ERROR: %s" % errorMsg)

   337

   338

   339

def fileBaseOf(filename, withPath=0):

   340

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

   341

   342

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

   343

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

   344

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

   345

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

   346

    path is excluded.

   347

   348

    [Example]

   349

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

   350

    >>> fileBaseOf(fn)

   351

    'test'

   352

    >>> fileBaseOf(fn)

   353

    'test'

   354

    >>> fileBaseOf(fn,1)

   355

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

   356

    >>> fileBaseOf(fn,0)

   357

    'test'

   358

    >>> fn = 'abcdef'

   359

    >>> fileBaseOf(fn)

   360

    'abcdef'

   361

    >>> fileBaseOf(fn,1)

   362

    'abcdef'

   363

    >>> fn = "abcdef."

   364

    >>> fileBaseOf(fn)

   365

    'abcdef'

   366

    >>> fileBaseOf(fn,1)

   367

    'abcdef'

   368

    """

   369

    pos = filename.rfind('.')

   370

    if pos > 0:

   371

        filename = filename[:pos]

   372

    if withPath:

   373

        return filename

   374

    else:

   375

        return os.path.basename(filename)

   376

   377

   378

def mkdir(directory):

   379

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

   380

   381

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

   382

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

   383

    solves this problem.  It creates every intermediate directory

   384

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

   385

    only supports forward slash separator, but under Windows and MacOS

   386

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

   387

    under windows).

   388

    """

   389

   390

    # translate the path separators

   391

    directory = unixpath(directory)

   392

    # build a list of all directory elements

   393

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

   394

    theLen = len(aList)

   395

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

   396

    # concatenate it with the first directory

   397

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

   398

        if theLen > 1:

   399

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

   400

            del aList[0]

   401

            theLen -= 1

   402

    # if the original directory starts at root,

   403

    # make sure the first element of the list

   404

    # starts at root too

   405

    if directory[0] == '/':

   406

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

   407

    # Now iterate through the list, check if the

   408

    # directory exists and if not create it

   409

    theDir = ''

   410

    for i in range(theLen):

   411

        theDir += aList[i]

   412

        if not os.path.exists(theDir):

   413

            os.mkdir(theDir)

   414

        theDir += '/'

   415

   416

   417

def unixpath(thePath):

   418

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

   419

   420

    [Example]

   421

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

   422

    'd:/test'

   423

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

   424

    'd:/test/file.txt'

   425

    >>>

   426

    """

   427

    thePath = os.path.normpath(thePath)

   428

    if os.sep == '/':

   429

        return thePath

   430

    else:

   431

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

   432

   433

   434

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

   435

   436

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

   437

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

   438

#

   439

if __name__ == "__main__":

   440

    import getopt     # command line parsing

   441

    argc = len(sys.argv)

   442

    if argc == 1:

   443

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

   444

        sys.exit(1)

   445

    # If there is some arguments, parse the command line

   446

    validOptions = "ehmpv"

   447

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

   448

    option = {}

   449

    option['forceEnglish'] = 0

   450

    option['mo'] = 0

   451

    option['po'] = 0

   452

    option['verbose'] = 0

   453

    option['domain'] = None

   454

    option['moTarget'] = None

   455

    optionKey = {

   456

        '-e':         'forceEnglish',

   457

        '-m':         'mo',

   458

        '-p':         'po',

   459

        '-v':         'verbose',

   460

        '--domain':   'domain',

   461

        '--moTarget': 'moTarget',

   462

    }

   463

    exit_code = 1

   464

    try:

   465

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

   466

    except getopt.GetoptError, e:

   467

        printUsage(e[0])

   468

        sys.exit(1)

   469

    for (opt, val) in optionList:

   470

        if opt == '-h':

   471

            printUsage()

   472

            sys.exit(0)

   473

        option[optionKey[opt]] = 1 if val == '' else val

   474

    if len(pargs) == 0:

   475

        appDirPath = os.getcwd()

   476

        if option['verbose']:

   477

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

   478

    elif len(pargs) == 1:

   479

        appDirPath = pargs[0]

   480

    else:

   481

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

   482

        sys.exit(1)

   483

    if option['domain'] is None:

   484

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

   485

        option['domain'] = fileBaseOf(appDirPath)

   486

    if option['verbose']:

   487

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

   488

    if option['po']:

   489

        try:

   490

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