Browse Source

new i18n_tool

master
Ulrich Carmesin 2 years ago
parent
commit
2443134bfc
  1. 96
      test/test_08i18n.py
  2. 4
      test/test_31db.py
  3. 6
      utils/config_tool.py
  4. 95
      utils/i18n_tool.py

96
test/test_08i18n.py

@ -0,0 +1,96 @@
#!/usr/bin/python
# -*- coding: utf-8 -*-
# ---------------------------------------------------------------------------------------------------------
# Author : Ulrich Carmesin
# Source : gitea.ucarmesin.de
# ---------------------------------------------------------------------------------------------------------
import unittest
import os
import inspect
import utils.path_tool
import basic.program
import basic.constants as B
import test.constants
import test.testtools
import utils.path_const as P
import utils.i18n_tool
import basic.constants as B
HOME_PATH = test.constants.HOME_PATH
OS_SYSTEM = test.constants.OS_SYSTEM
# here you can select single testfunction for developping the tests
TEST_FUNCTIONS = ["test_01class", "test_02text", "test_03aliasList"]
#TEST_FUNCTIONS = [ "test_03aliasList"]
verbose = False
EXP_KEY_MISSING = "key is missing {}"
EXP_KEY_DOESNT_EXIST = "key doesnt exist in domain {}"
class MyTestCase(unittest.TestCase):
mymsg = "--------------------------------------------------------------"
def test_01class(self):
global mymsg
actfunction = str(inspect.currentframe().f_code.co_name)
cnttest = 0
if actfunction not in TEST_FUNCTIONS:
return
job = test.testtools.getJob()
i18n = utils.i18n_tool.I18n.getInstance()
self.assertIsNotNone(i18n)
cnttest += 1
MyTestCase.mymsg += "\n----- "+actfunction+" : "+str(cnttest)
def test_02text(self):
global mymsg
actfunction = str(inspect.currentframe().f_code.co_name)
cnttest = 0
if actfunction not in TEST_FUNCTIONS:
return
job = test.testtools.getJob()
job.conf.confs["language"] = "de"
i18n = utils.i18n_tool.I18n.getInstance()
res = i18n.getText(f"{EXP_KEY_MISSING=}", job)
if verbose: print("RESULT "+res)
self.assertEqual(res, "Schluesselwort fehlt {}")
cnttest += 1
res = i18n.getText(f"{EXP_KEY_DOESNT_EXIST=}", job)
if verbose: print("RESULT "+res)
self.assertEqual(res, "key doesnt exist in domain {}")
cnttest += 1
res = i18n.getText(f"{B.ATTR_APPS_PROJECT=}", job)
if verbose: print("RESULT "+res)
self.assertEqual(res, "project")
cnttest += 1
job.conf.confs["language"] = "fr"
i18n = utils.i18n_tool.I18n.getInstance()
self.assertRaises(Exception, i18n.getText, (f"{EXP_KEY_MISSING=}", job))
cnttest += 1
MyTestCase.mymsg += "\n----- "+actfunction+" : "+str(cnttest)
def test_03aliasList(self):
global mymsg
actfunction = str(inspect.currentframe().f_code.co_name)
cnttest = 0
if actfunction not in TEST_FUNCTIONS:
return
job = test.testtools.getJob()
job.conf.confs["language"] = "de"
i18n = utils.i18n_tool.I18n.getInstance()
# i18n.getText("EXP_KEY_MISSING", EXP_KEY_MISSING, job)
res = i18n.getAliasList(f"{EXP_KEY_MISSING=}", job)
if verbose: print("RESULT "+str(res))
self.assertEqual(res, ['key is missing {}', 'Schluesselwort fehlt {}'])
cnttest += 1
MyTestCase.mymsg += "\n----- "+actfunction+" : "+str(cnttest)
def test_zzz(self):
if verbose: print(MyTestCase.mymsg)
if __name__ == '__main__':
verbose = True
unittest.main()

4
test/test_31db.py

@ -21,8 +21,8 @@ HOME_PATH = test.constants.HOME_PATH
conf = {}
# here you can select single testfunction for developping the tests
# "test_toolhandling", "test_parseSql" -> test of components
TEST_FUNCTIONS = ["test_formatDbRows", "test_getTechnicalIDFields"]
TEST_FUNCTIONS = ["test_getTechnicalIDFields"]
TEST_FUNCTIONS = ["test_formatDbRows"]
# TEST_FUNCTIONS = ["test_getTechnicalIDFields"]
class MyTestCase(unittest.TestCase):
mymsg = "--------------------------------------------------------------"

6
utils/config_tool.py

@ -44,6 +44,12 @@ def getConfigPath(modul, name, subname=""):
job.debug(verify, "getConfig " + modul + ", " + name)
#TODO path rejoin, config as const
if modul == P.KEY_TOOL:
for format in CONFIG_FORMAT:
pathname = os.path.join(job.conf.getPath(P.ATTR_PATH_COMPONENTS),
P.KEY_TOOL+"_"+name+"."+format)
job.debug(verify, "1 " + pathname)
if os.path.exists(pathname):
return pathname
for format in CONFIG_FORMAT:
pathname = os.path.join(job.conf.getPath(P.ATTR_PATH_HOME),
P.VAL_CONFIG, P.KEY_TOOL+"_"+name+"."+format)

95
utils/i18n_tool.py

@ -0,0 +1,95 @@
#!/usr/bin/python
# -*- coding: utf-8 -*-
# ---------------------------------------------------------------------------------------------------------
# Author : Ulrich Carmesin
# Source : gitea.ucarmesin.de
# ---------------------------------------------------------------------------------------------------------
import utils.config_tool
import utils.path_const as P
import basic.program
DEFAULT_LANGUAGE = "en"
EXP_KEY_MISSING = "key is missing {}"
EXP_KEY_DOESNT_EXIST = "key doesnt exist in domain {}"
class I18n:
__instance = None
cache = {}
"""
in this class there should be managed each defined key-value-pairs
the pairs ara loaded from the path testdata/catalog:
* initially the csv-file catalog.csv
* on demand other csv-files in the path
"""
def __init__(self):
self.cache = {}
self.cache = utils.config_tool.getConfig(P.KEY_TOOL, "i18n")
I18n.__instance = self
pass
@staticmethod
def getInstance():
if I18n.__instance == None:
return I18n()
return I18n.__instance
def getText(self, key, job=None):
"""
this function gets the text depending on language which is set in job.conf
:param domain:
:param key:
:return:
if not (isinstance(langue, str) and len(langue)):
raise Exception(EXP_KEY_MISSING, (domain, key))
if not (isinstance(key, str) and len(key)):
raise Exception(EXP_KEY_MISSING, (langue, key))
return self.cache[langue][key]
"""
if job is None:
jon = basic.program.Job.getInstance()
language = job.conf.confs["language"]
if language not in self.cache:
raise Exception(EXP_KEY_MISSING, (key))
print(key)
out = self.extractText(key)
key = self.extractKey(key)
if key in self.cache[language]:
out = self.cache[language][key]
elif key in self.cache[DEFAULT_LANGUAGE]:
out = self.cache[DEFAULT_LANGUAGE][key]
return out
def getAliasList(self, key, job=None):
if job is None:
jon = basic.program.Job.getInstance()
out = []
key = self.extractKey(key)
for language in self.cache:
out.append(self.cache[language][key])
return out
def extractKey(self, key):
if "=" in key:
i = key.find("=")
x = key[0:i]
if "." in x:
i = x.find(".")
y = x[i + 1:]
else:
y = x
key = y
print("= in key " + y)
else:
print("!= in key")
y = key
return key
def extractText(self, key):
if "=" in key:
i = key.find("=")
return key[i + 2:-1]
return ""
Loading…
Cancel
Save