1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz

     5

# Copyright (C) 2021: Edouard TISSERANT

     6

#

     7

# See COPYING file for copyrights details.

     8

     9

from __future__ import absolute_import

    10

from lxml import etree

    11

import os

    12

import sys

    13

import subprocess

    14

import time

    15

import ast

    16

import wx

    17

import re

    18

    19

# to have it for python 2, had to install 

    20

# https://pypi.org/project/pycountry/18.12.8/

    21

# python2 -m pip install pycountry==18.12.8 --user

    22

import pycountry

    23

from dialogs import MessageBoxOnce

    24

    25

cmd_parser = re.compile(r'(?:"([^"]+)"\s*|([^\s]+)\s*)?')

    26

    27

def open_pofile(pofile):

    28

    """ Opens PO file with POEdit """

    29

    30

    if sys.platform.startswith('win'):

    31

        from six.moves import winreg

    32

        poedit_cmd = None

    33

        try:

    34

            poedit_cmd = winreg.QueryValue(winreg.HKEY_LOCAL_MACHINE,

    35

                                           'SOFTWARE\\Classes\\poedit\\shell\\open\\command')

    36

            cmd = re.findall(cmd_parser, poedit_cmd)

    37

            dblquote_value,smpl_value = cmd[0]

    38

            poedit_path = dblquote_value+smpl_value

    39

        except OSError:

    40

            poedit_path = None

    41

    42

    else:

    43

        if os.environ.has_key("SNAP"):

    44

            MessageBoxOnce("Launching POEdit with xdg-open",

    45

                    "Confined app can't launch POEdit directly.\n"+

    46

                        "Instead, PO/POT file is passed to xdg-open.\n"+

    47

                        "Please select POEdit when proposed.\n\n"+

    48

                    "Notes: \n"+

    49

                    " - POEdit must be installed on you system.\n"+

    50

                    " - If no choice is proposed, use file manager to change POT/PO file properties.\n",

    51

                    "SVGHMII18SnapWarning")

    52

            poedit_path = "xdg-open"

    53

        else:

    54

            try:

    55

                poedit_path = subprocess.check_output("command -v poedit", shell=True).strip()

    56

            except subprocess.CalledProcessError:

    57

                poedit_path = None

    58

    59

    if poedit_path is None:

    60

        wx.MessageBox("POEdit is not found or installed !")

    61

    else:

    62

        subprocess.Popen([poedit_path,pofile])

    63

    64

def EtreeToMessages(msgs):

    65

    """ Converts XML tree from 'extract_i18n' templates into a list of tuples """

    66

    messages = []

    67

    68

    for msg in msgs:

    69

        messages.append((

    70

            "\n".join([line.text for line in msg]),

    71

            msg.get("label"), msg.get("id")))

    72

    73

    return messages

    74

    75

def SaveCatalog(fname, messages):

    76

    """ Save messages given as list of tupple (msg,label,id) in POT file """

    77

    w = POTWriter()

    78

    w.ImportMessages(messages)

    79

    80

    with open(fname, 'w') as POT_file:

    81

        w.write(POT_file)

    82

    83

def GetPoFiles(dirpath):

    84

    po_files = [fname for fname in os.listdir(dirpath) if fname.endswith(".po")]

    85

    po_files.sort()

    86

    return [(po_fname[:-3],os.path.join(dirpath, po_fname)) for po_fname in po_files]

    87

    88

def ReadTranslations(dirpath):

    89

    """ Read all PO files from a directory and return a list of (langcode, translation_dict) tuples """

    90

    91

    translations = []

    92

    for translation_name, po_path in GetPoFiles(dirpath):

    93

        r = POReader()

    94

        with open(po_path, 'r') as PO_file:

    95

            r.read(PO_file)

    96

            translations.append((translation_name, r.get_messages()))

    97

    return translations

    98

    99

def MatchTranslations(translations, messages, errcallback):

   100

    """

   101

    Matches translations against original message catalog,

   102

    warn about inconsistancies,

   103

    returns list of langs, and a list of (msgid, [translations]) tuples

   104

    """

   105

    translated_messages = []

   106

    broken_lang = set()

   107

    for msgid,label,svgid in messages:

   108

        translated_message = []

   109

        for langcode,translation in translations:

   110

            msg = translation.pop(msgid, None)

   111

            if msg is None:

   112

                broken_lang.add(langcode)

   113

                errcallback(_('{}: Missing translation for "{}" (label:{}, id:{})\n').format(langcode,msgid,label,svgid))

   114

                translated_message.append(msgid)

   115

            else:

   116

                translated_message.append(msg)

   117

        translated_messages.append((msgid,translated_message))

   118

    langs = []

   119

    for langcode,translation in translations:

   120

        try:

   121

            l,c = langcode.split("_")

   122

            language_name = pycountry.languages.get(alpha_2 = l).name

   123

            country_name = pycountry.countries.get(alpha_2 = c).name

   124

            langname = "{} ({})".format(language_name, country_name)

   125

        except:

   126

            try:

   127

                langname = pycountry.languages.get(alpha_2 = langcode).name

   128

            except:

   129

                langname = langcode

   130

   131

        langs.append((langname,langcode))

   132

   133

        broken = False

   134

        for msgid, msg in translation.iteritems():

   135

            broken = True

   136

            errcallback(_('{}: Unused translation "{}":"{}"\n').format(langcode,msgid,msg))

   137

        if broken or langcode in broken_lang:

   138

            errcallback(_('Translation for {} is outdated, please edit {}.po, click "Catalog -> Update from POT File..." and select messages.pot.\n').format(langcode,langcode))

   139

   140

   141

    return langs,translated_messages

   142

   143

   144

def TranslationToEtree(langs,translated_messages):

   145

   146

    result = etree.Element("translations")

   147

   148

    langsroot = etree.SubElement(result, "langs")

   149

    for name, code in langs:

   150

        langel = etree.SubElement(langsroot, "lang", {"code":code})

   151

        langel.text = name

   152

   153

    msgsroot = etree.SubElement(result, "messages")

   154

    for msgid, msgs in translated_messages:

   155

        msgidel = etree.SubElement(msgsroot, "msgid")

   156

        for msg in msgs:

   157

            msgel = etree.SubElement(msgidel, "msg")

   158

            for line in msg.split("\n"):

   159

                lineel = etree.SubElement(msgel, "line")

   160

                lineel.text = escape(line.encode("utf-8")).decode("utf-8")

   161

   162

    return result

   163

   164

   165

   166

locpfx = '#:svghmi.svg:'

   167

   168

pot_header = '''\

   169

# SOME DESCRIPTIVE TITLE.

   170

# Copyright (C) YEAR ORGANIZATION

   171

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

   172

#

   173

msgid ""

   174

msgstr ""

   175

"Project-Id-Version: PACKAGE VERSION\\n"

   176

"POT-Creation-Date: %(time)s\\n"

   177

"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\\n"

   178

"Last-Translator: FULL NAME <EMAIL@ADDRESS>\\n"

   179

"Language-Team: LANGUAGE <LL@li.org>\\n"

   180

"MIME-Version: 1.0\\n"

   181

"Content-Type: text/plain; charset=UTF-8\\n"

   182

"Content-Transfer-Encoding: 8bit\\n"

   183

"Generated-By: SVGHMI 1.0\\n"

   184

   185

'''

   186

escapes = []

   187

   188

def make_escapes(pass_iso8859):

   189

    global escapes

   190

    escapes = [chr(i) for i in range(256)]

   191

    if pass_iso8859:

   192

        # Allow iso-8859 characters to pass through so that e.g. 'msgid

   193

        # "Höhe"' would result not result in 'msgid "H\366he"'.  Otherwise we

   194

        # escape any character outside the 32..126 range.

   195

        mod = 128

   196

    else:

   197

        mod = 256

   198

    for i in range(mod):

   199

        if not(32 <= i <= 126):

   200

            escapes[i] = "\\%03o" % i

   201

    escapes[ord('\\')] = '\\\\'

   202

    escapes[ord('\t')] = '\\t'

   203

    escapes[ord('\r')] = '\\r'

   204

    escapes[ord('\n')] = '\\n'

   205

    escapes[ord('\"')] = '\\"'

   206

   207

make_escapes(pass_iso8859 = True)

   208

   209

EMPTYSTRING = ''

   210

   211

def escape(s):

   212

    global escapes

   213

    s = list(s)

   214

    for i in range(len(s)):

   215

        s[i] = escapes[ord(s[i])]

   216

    return EMPTYSTRING.join(s)

   217

   218

def normalize(s):

   219

    # This converts the various Python string types into a format that is

   220

    # appropriate for .po files, namely much closer to C style.

   221

    lines = s.split('\n')

   222

    if len(lines) == 1:

   223

        s = '"' + escape(s) + '"'

   224

    else:

   225

        if not lines[-1]:

   226

            del lines[-1]

   227

            lines[-1] = lines[-1] + '\n'

   228

        for i in range(len(lines)):

   229

            lines[i] = escape(lines[i])

   230

        lineterm = '\\n"\n"'

   231

        s = '""\n"' + lineterm.join(lines) + '"'

   232

    return s

   233

   234

   235

class POTWriter:

   236

    def __init__(self):

   237

        self.__messages = {}

   238

   239

    def ImportMessages(self, msgs):

   240

        for  msg, label, svgid in msgs:

   241

            self.addentry(msg.encode("utf-8"), label, svgid)

   242

   243

    def addentry(self, msg, label, svgid):

   244

        entry = (label, svgid)

   245

        self.__messages.setdefault(msg, set()).add(entry)

   246

   247

    def write(self, fp):

   248

        timestamp = time.strftime('%Y-%m-%d %H:%M+%Z')

   249

        print >> fp, pot_header % {'time': timestamp}

   250

        reverse = {}

   251

        for k, v in self.__messages.items():

   252

            keys = list(v)

   253

            keys.sort()

   254

            reverse.setdefault(tuple(keys), []).append((k, v))

   255

        rkeys = reverse.keys()

   256

        rkeys.sort()

   257

        for rkey in rkeys:

   258

            rentries = reverse[rkey]

   259

            rentries.sort()

   260

            for k, v in rentries:

   261

                v = list(v)

   262

                v.sort()

   263

                locline = locpfx

   264

                for label, svgid in v:

   265

                    d = {'label': label, 'svgid': svgid}

   266

                    s = _(' %(label)s:%(svgid)s') % d

   267

                    if len(locline) + len(s) <= 78:

   268

                        locline = locline + s

   269

                    else:

   270

                        print >> fp, locline

   271

                        locline = locpfx + s

   272

                if len(locline) > len(locpfx):

   273

                    print >> fp, locline

   274

                print >> fp, 'msgid', normalize(k)

   275

                print >> fp, 'msgstr ""\n'

   276

   277

   278

class POReader:

   279

    def __init__(self):

   280

        self.__messages = {}

   281

   282

    def get_messages(self):

   283

        return self.__messages

   284

   285

    def add(self, msgid, msgstr, fuzzy):

   286

        "Add a non-fuzzy translation to the dictionary."

   287

        if not fuzzy and msgstr and msgid:

   288

            self.__messages[msgid.decode('utf-8')] = msgstr.decode('utf-8')

   289

   290

    def read(self, fp):

   291

        ID = 1

   292

        STR = 2

   293

   294

        lines = fp.readlines()

   295

        section = None

   296

        fuzzy = 0

   297

   298

        # Parse the catalog

   299

        lno = 0

   300

        for l in lines:

   301

            lno += 1

   302

            # If we get a comment line after a msgstr, this is a new entry

   303

            if l[0] == '#' and section == STR:

   304

                self.add(msgid, msgstr, fuzzy)

   305

                section = None

   306

                fuzzy = 0

   307

            # Record a fuzzy mark

   308

            if l[:2] == '#,' and 'fuzzy' in l:

   309

                fuzzy = 1

   310

            # Skip comments

   311

            if l[0] == '#':

   312

                continue

   313

            # Now we are in a msgid section, output previous section

   314

            if l.startswith('msgid') and not l.startswith('msgid_plural'):

   315

                if section == STR:

   316

                    self.add(msgid, msgstr, fuzzy)

   317

                section = ID

   318

                l = l[5:]

   319

                msgid = msgstr = ''

   320

                is_plural = False

   321

            # This is a message with plural forms

   322

            elif l.startswith('msgid_plural'):

   323

                if section != ID:

   324

                    print >> sys.stderr, 'msgid_plural not preceded by msgid on %s:%d' %\

   325

                        (infile, lno)

   326

                    sys.exit(1)

   327

                l = l[12:]

   328

                msgid += '\0' # separator of singular and plural

   329

                is_plural = True

   330

            # Now we are in a msgstr section

   331

            elif l.startswith('msgstr'):

   332

                section = STR

   333

                if l.startswith('msgstr['):

   334

                    if not is_plural:

   335

                        print >> sys.stderr, 'plural without msgid_plural on %s:%d' %\

   336

                            (infile, lno)

   337

                        sys.exit(1)

   338

                    l = l.split(']', 1)[1]

   339

                    if msgstr:

   340

                        msgstr += '\0' # Separator of the various plural forms

   341

                else:

   342

                    if is_plural:

   343

                        print >> sys.stderr, 'indexed msgstr required for plural on  %s:%d' %\

   344

                            (infile, lno)

   345

                        sys.exit(1)

   346

                    l = l[6:]

   347

            # Skip empty lines

   348

            l = l.strip()

   349

            if not l:

   350

                continue

   351

            l = ast.literal_eval(l)

   352

            if section == ID:

   353

                msgid += l

   354

            elif section == STR:

   355

                msgstr += l

   356

            else:

   357

                print >> sys.stderr, 'Syntax error on %s:%d' % (infile, lno), \

   358

                      'before:'

   359

                print >> sys.stderr, l

   360

                sys.exit(1)

   361

        # Add last entry

   362

        if section == STR:

   363

            self.add(msgid, msgstr, fuzzy)

   364

   365