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

    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

from email.parser import HeaderParser

    19

    20

import pycountry

    21

from dialogs import MessageBoxOnce

    22

from POULibrary import UserAddressedException

    23

    24

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

    25

    26

def open_pofile(pofile):

    27

    """ Opens PO file with POEdit """

    28

    29

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

    30

        from six.moves import winreg

    31

        poedit_cmd = None

    32

        try:

    33

            poedit_cmd = winreg.QueryValue(winreg.HKEY_LOCAL_MACHINE,

    34

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

    35

            cmd = re.findall(cmd_parser, poedit_cmd)

    36

            dblquote_value,smpl_value = cmd[0]

    37

            poedit_path = dblquote_value+smpl_value

    38

        except OSError:

    39

            poedit_path = None

    40

    41

    else:

    42

        if "SNAP" in os.environ:

    43

            MessageBoxOnce("Launching POEdit with xdg-open",

    44

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

    45

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

    46

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

    47

                    "Notes: \n"+

    48

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

    49

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

    50

                    "SVGHMII18SnapWarning")

    51

            poedit_path = "xdg-open"

    52

        else:

    53

            try:

    54

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

    55

            except subprocess.CalledProcessError:

    56

                poedit_path = None

    57

    58

    if poedit_path is None:

    59

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

    60

    else:

    61

        subprocess.Popen([poedit_path,pofile])

    62

    63

def EtreeToMessages(msgs):

    64

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

    65

    messages = []

    66

    67

    for msg in msgs:

    68

        messages.append((

    69

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

    70

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

    71

    72

    return messages

    73

    74

def SaveCatalog(fname, messages):

    75

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

    76

    w = POTWriter()

    77

    w.ImportMessages(messages)

    78

    79

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

    80

        w.write(POT_file)

    81

    82

def GetPoFiles(dirpath):

    83

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

    84

    po_files.sort()

    85

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

    86

    87

def ReadTranslations(dirpath):

    88

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

    89

    90

    translations = []

    91

    for translation_name, po_path in GetPoFiles(dirpath):

    92

        r = POReader()

    93

        r.read(po_path)

    94

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

    95

    return translations

    96

    97

def MatchTranslations(translations, messages, errcallback):

    98

    """

    99

    Matches translations against original message catalog,

   100

    warn about inconsistancies,

   101

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

   102

    """

   103

    translated_messages = []

   104

    broken_lang = set()

   105

    for msgid,label,svgid in messages:

   106

        translated_message = []

   107

        for langcode,translation in translations:

   108

            msg = translation.pop(msgid, None)

   109

            if msg is None:

   110

                broken_lang.add(langcode)

   111

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

   112

                translated_message.append(msgid)

   113

            else:

   114

                translated_message.append(msg)

   115

        translated_messages.append((msgid,translated_message))

   116

    langs = []

   117

    for langcode,translation in translations:

   118

        try:

   119

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

   120

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

   121

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

   122

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

   123

        except:

   124

            try:

   125

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

   126

            except:

   127

                langname = langcode

   128

   129

        langs.append((langname,langcode))

   130

   131

        broken = False

   132

        for msgid, msg in translation.items():

   133

            broken = True

   134

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

   135

        if broken or langcode in broken_lang:

   136

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

   137

   138

   139

    return langs,translated_messages

   140

   141

   142

def TranslationToEtree(langs,translated_messages):

   143

   144

    result = etree.Element("translations")

   145

   146

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

   147

    for name, code in langs:

   148

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

   149

        langel.text = name

   150

   151

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

   152

    for msgid, msgs in translated_messages:

   153

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

   154

        for msg in msgs:

   155

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

   156

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

   157

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

   158

                lineel.text = escape(line).decode()

   159

   160

    return result

   161

   162

# Code below is based on :

   163

#  cpython/Tools/i18n/pygettext.py

   164

#  cpython/Tools/i18n/msgfmt.py

   165

   166

locpfx = b'#: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

   186

'''

   187

escapes = []

   188

   189

def make_escapes():

   190

    global escapes

   191

    escapes = [b"\%03o" % i for i in range(128)]

   192

    for i in range(32, 127):

   193

        escapes[i] = bytes([i])

   194

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

   195

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

   196

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

   197

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

   198

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

   199

   200

make_escapes()

   201

   202

def escape(s):

   204

   205

def normalize(s):

   206

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

   207

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

   208

    lines = s.split(b'\n')

   209

    if len(lines) == 1:

   210

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

   211

    else:

   212

        if not lines[-1]:

   213

            del lines[-1]

   214

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

   215

        for i in range(len(lines)):

   216

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

   217

        lineterm = b'\\n"\n"'

   218

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

   219

    return s

   220

   221

class POTWriter:

   222

    def __init__(self):

   223

        self.__messages = {}

   224

   225

    def ImportMessages(self, msgs):

   226

        for  msg, label, svgid in msgs:

   227

            self.addentry(msg, label, svgid)

   228

   229

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

   230

        entry = (label, svgid)

   231

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

   232

   233

    def write(self, fp):

   234

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

   235

        header = pot_header % {'time': timestamp}

   236

        fp.write(header.encode())

   237

        reverse = {}

   238

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

   239

            keys = list(v)

   240

            keys.sort()

   241

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

   242

        rkeys = sorted(reverse.keys())

   243

        for rkey in rkeys:

   244

            rentries = reverse[rkey]

   245

            rentries.sort()

   246

            for k, v in rentries:

   247

                v = list(v)

   248

                v.sort()

   249

                locline = locpfx

   250

                for label, svgid in v:

   251

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

   252

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

   253

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

   254

                        locline = locline + s

   255

                    else:

   257

                        locline = locpfx + s

   258

                if len(locline) > len(locpfx):

   262

   263

   264

class POReader:

   265

    def __init__(self):

   266

        self.__messages = {}

   267

   268

    def get_messages(self):

   269

        return self.__messages

   270

   271

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

   272

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

   273

        if not fuzzy and msgstr and msgid:

   274

            if ctxt is None:

   275

                self.__messages[msgid] = msgstr

   276

            else:

   277

                self.__messages[b"%b\x04%b" % (ctxt, id)] = str

   278

   279

    def read(self, infile):

   280

        ID = 1

   281

        STR = 2

   282

        CTXT = 3

   283

   284

   285

        with open(infile, 'rb') as f:

   286

            lines = f.readlines()

   287

   288

        section = msgctxt = None

   289

        fuzzy = 0

   290

   291

        # Start off assuming Latin-1, so everything decodes without failure,

   292

        # until we know the exact encoding

   293

        encoding = 'latin-1'

   294

   295

        # Parse the catalog

   296

        lno = 0

   297

        for l in lines:

   298

            l = l.decode(encoding)

   299

            lno += 1

   300

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

   301

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

   302

                self.add(msgctxt, msgid, msgstr, fuzzy)

   303

                section = msgctxt = None

   304

                fuzzy = 0

   305

            # Record a fuzzy mark

   306

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

   307

                fuzzy = 1

   308

            # Skip comments

   309

            if l[0] == '#':

   310

                continue

   311

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

   312

            if l.startswith('msgctxt'):

   313

                if section == STR:

   314

                    self.add(msgctxt, msgid, msgstr, fuzzy)

   315

                section = CTXT

   316

                l = l[7:]

   317

                msgctxt = b''

   318

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

   319

                if section == STR:

   320

                    self.add(msgctxt, msgid, msgstr, fuzzy)

   321

                    if not msgid:

   322

                        # See whether there is an encoding declaration

   323

                        p = HeaderParser()

   324

                        charset = p.parsestr(msgstr.decode(encoding)).get_content_charset()

   325

                        if charset:

   326

                            encoding = charset

   327

                section = ID

   328

                l = l[5:]

   329

                msgid = msgstr = b''

   330

                is_plural = False

   331

            # This is a message with plural forms

   332

            elif l.startswith('msgid_plural'):

   333

                if section != ID:

   334

                    raise UserAddressedException(

   335

                        'msgid_plural not preceded by msgid on %s:%d' % (infile, lno))

   336

                l = l[12:]

   337

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

   338

                is_plural = True

   339

            # Now we are in a msgstr section

   340

            elif l.startswith('msgstr'):

   341

                section = STR

   342

                if l.startswith('msgstr['):

   343

                    if not is_plural:

   344

                        raise UserAddressedException(

   345

                            'plural without msgid_plural on %s:%d' % (infile, lno))

   346

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

   347

                    if msgstr:

   348

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

   349

                else:

   350

                    if is_plural:

   351

                        raise UserAddressedException(

   352

                            'indexed msgstr required for plural on  %s:%d' % (infile, lno))

   353

                    l = l[6:]

   354

            # Skip empty lines

   355

            l = l.strip()

   356

            if not l:

   357

                continue

   358

            l = ast.literal_eval(l)

   359

            if section == CTXT:

   360

                msgctxt += l.encode(encoding)

   361

            elif section == ID:

   362

                msgid += l.encode(encoding)

   363

            elif section == STR:

   364

                msgstr += l.encode(encoding)

   365

            else:

   366

                raise UserAddressedException(

   367

                    'Syntax error on %s:%d' % (infile, lno) + 'before:\n %s'%l)

   368

        # Add last entry

   369

        if section == STR:

   370

            self.add(msgctxt, msgid, msgstr, fuzzy)

   371

   372

   373