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

        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

        messages = POReader().read(po_path)

    93

        translations.append((translation_name, messages))

    94

    return translations

    95

    96

def MatchTranslations(translations, messages, errcallback):

    97

    """

    98

    Matches translations against original message catalog,

    99

    warn about inconsistancies,

   100

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

   101

    """

   102

    translated_messages = []

   103

    broken_lang = set()

   104

    incomplete_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

                # Missing translation (msgid not in .po)

   111

                broken_lang.add(langcode)

   112

                msg = msgid

   113

            elif msg == b"":

   114

                # Empty translation (msgid is in .po)

   115

                incomplete_lang.add(langcode)

   116

                msg = msgid

   117

   118

            translated_message.append(msg)

   119

        translated_messages.append((msgid,translated_message))

   120

    langs = []

   121

    for langcode,translation in translations:

   122

        try:

   123

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

   124

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

   125

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

   126

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

   127

        except:

   128

            try:

   129

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

   130

            except:

   131

                langname = langcode

   132

   133

        langs.append((langname,langcode))

   134

   135

        broken = False

   136

        if translation:

   137

            broken = True

   138

        if broken or langcode in broken_lang:

   139

            errcallback((

   140

                    _('Translation for {} is outdated and incomplete.') 

   141

                    if langcode in incomplete_lang else

   142

                    _('Translation for {} is outdated.')).format(langcode) + 

   143

                " "+_('Edit {}.po, click "Catalog -> Update from POT File..." and select messages.pot.\n').format(langcode))

   144

        elif langcode in incomplete_lang:

   145

            errcallback(_('Translation for {} is incomplete. Edit {}.po to complete it.\n').format(langcode,langcode))

   146

   147

   148

    return langs,translated_messages

   149

   150

   151

def TranslationToEtree(langs,translated_messages):

   152

   153

    result = etree.Element("translations")

   154

   155

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

   156

    for name, code in langs:

   157

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

   158

        langel.text = name

   159

   160

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

   161

    for msgid, msgs in translated_messages:

   162

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

   163

        for msg in msgs:

   164

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

   165

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

   166

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

   167

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

   168

   169

    return result

   170

   171

# Code below is based on :

   172

#  cpython/Tools/i18n/pygettext.py

   173

#  cpython/Tools/i18n/msgfmt.py

   174

   175

locpfx = b'#:svghmi.svg:'

   176

   177

pot_header = '''\

   178

# SOME DESCRIPTIVE TITLE.

   179

# Copyright (C) YEAR ORGANIZATION

   180

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

   181

#

   182

msgid ""

   183

msgstr ""

   184

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

   185

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

   186

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

   187

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

   188

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

   189

"MIME-Version: 1.0\\n"

   190

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

   191

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

   192

"Generated-By: SVGHMI 1.0\\n"

   193

   194

   195

'''

   196

escapes = []

   197

   198

def make_escapes():

   199

    global escapes

   200

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

   201

    for i in range(32, 127):

   202

        escapes[i] = bytes([i])

   203

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

   204

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

   205

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

   206

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

   207

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

   208

   209

make_escapes()

   210

   211

def escape(s):

   212

    return b''.join([escapes[c] if c < 128 else bytes([c]) for c in s])

   213

   214

def normalize(s):

   215

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

   216

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

   217

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

   218

    if len(lines) == 1:

   219

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

   220

    else:

   221

        if not lines[-1]:

   222

            del lines[-1]

   223

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

   224

        for i in range(len(lines)):

   225

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

   226

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

   227

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

   228

    return s

   229

   230

class POTWriter:

   231

    def __init__(self):

   232

        self.__messages = {}

   233

   234

    def ImportMessages(self, msgs):

   235

        for  msg, label, svgid in msgs:

   236

            self.addentry(msg, label, svgid)

   237

   238

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

   239

        entry = (label, svgid)

   240

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

   241

   242

    def write(self, fp):

   243

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

   244

        header = pot_header % {'time': timestamp}

   245

        fp.write(header.encode())

   246

        reverse = {}

   247

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

   248

            keys = list(v)

   249

            keys.sort()

   250

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

   251

        rkeys = sorted(reverse.keys())

   252

        for rkey in rkeys:

   253

            rentries = reverse[rkey]

   254

            rentries.sort()

   255

            for k, v in rentries:

   256

                v = list(v)

   257

                v.sort()

   258

                locline = locpfx

   259

                for label, svgid in v:

   260

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

   261

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

   262

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

   263

                        locline = locline + s

   264

                    else:

   265

                        fp.write(locline + b'\n')

   266

                        locline = locpfx + s

   267

                if len(locline) > len(locpfx):

   268

                    fp.write(locline + b'\n')

   269

                fp.write(b'msgid ' + normalize(k) + b'\n')

   270

                fp.write(b'msgstr ""\n\n')

   271

   272

   273

class POReader:

   274

    def __init__(self):

   275

        self.__messages = {}

   276

   277

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

   278

        "Add eventually empty translation to the dictionary."

   279

        if msgid:

   280

            self.__messages[msgid if ctxt is None else (b"%b\x04%b" % (ctxt, id))] = msgstr

   281

   282

    def read(self, infile):

   283

        ID = 1

   284

        STR = 2

   285

        CTXT = 3

   286

   287

        self.__messages = {}

   288

   289

        try:

   290

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

   291

                lines = f.readlines()

   292

        except Exception as e:

   293

            raise UserAddressedException(

   294

                        'Cannot open PO translation file :%s' % str(e))

   295

   296

        section = msgctxt = None

   297

        fuzzy = 0

   298

   299

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

   300

        # until we know the exact encoding

   301

        encoding = 'latin-1'

   302

   303

        # Parse the catalog

   304

        lno = 0

   305

        for l in lines:

   306

            l = l.decode(encoding)

   307

            lno += 1

   308

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

   309

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

   310

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

   311

                section = msgctxt = None

   312

                fuzzy = 0

   313

            # Record a fuzzy mark

   314

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

   315

                fuzzy = 1

   316

            # Skip comments

   317

            if l[0] == '#':

   318

                continue

   319

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

   320

            if l.startswith('msgctxt'):

   321

                if section == STR:

   322

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

   323

                    fuzzy = 0

   324

                section = CTXT

   325

                l = l[7:]

   326

                msgctxt = b''

   327

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

   328

                if section == STR:

   329

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

   330

                    fuzzy = 0

   331

                    if not msgid:

   332

                        # See whether there is an encoding declaration

   333

                        p = HeaderParser()

   334

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

   335

                        if charset:

   336

                            encoding = charset

   337

                section = ID

   338

                l = l[5:]

   339

                msgid = msgstr = b''

   340

                is_plural = False

   341

            # This is a message with plural forms

   342

            elif l.startswith('msgid_plural'):

   343

                if section != ID:

   344

                    raise UserAddressedException(

   345

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

   346

                l = l[12:]

   347

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

   348

                is_plural = True

   349

            # Now we are in a msgstr section

   350

            elif l.startswith('msgstr'):

   351

                section = STR

   352

                if l.startswith('msgstr['):

   353

                    if not is_plural:

   354

                        raise UserAddressedException(

   355

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

   356

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

   357

                    if msgstr:

   358

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

   359

                else:

   360

                    if is_plural:

   361

                        raise UserAddressedException(

   362

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

   363

                    l = l[6:]

   364

            # Skip empty lines

   365

            l = l.strip()

   366

            if not l:

   367

                continue

   368

            l = ast.literal_eval(l)

   369

            if section == CTXT:

   370

                msgctxt += l.encode(encoding)

   371

            elif section == ID:

   372

                msgid += l.encode(encoding)

   373

            elif section == STR:

   374

                msgstr += l.encode(encoding)

   375

            else:

   376

                raise UserAddressedException(

   377

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

   378

        # Add last entry

   379

        if section == STR:

   380

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

   381

   382

        return self.__messages

   383

   384

   385