Exemple #1
0
  def init_list( self):
    langs = []
    import gettext
    self.languages = {}
    for lang, language in data.languages.items():
      system = gettext.find('BKChem', os.path.normpath(os.path.join(
        os_support.get_bkchem_run_dir(), '../../../../share/locale')), [lang])
      if not system:
        system = gettext.find('BKChem', None, [lang])
      local = gettext.find( 'BKChem', os.path.normpath( os.path.join( os_support.get_bkchem_run_dir(), '../locale')), [lang])
      if system or local or lang == "en":
        lang_text = "%s (%s)" % (language, lang)
        langs.append( lang_text)
        self.languages[lang_text] = lang
    langs.sort()
    # default
    default = "%s (default)"%_("System default")
    self.languages[default] = "default"
    langs.append( default)

    self.list = Pmw.ScrolledListBox( self.interior(),
                                     #selectioncommand=self.select,
                                     labelpos = "n",
                                     label_text=_("Available Languages"),
                                     listbox_selectmode="single",
                                     listbox_width=30,
                                     items=langs)
    del gettext
    self.list.pack()
	def __init__(self): 
		# Change this variable to your app name!
		#  The translation files will be under
		#  @LOCALE_DIR@/@LANGUAGE@/LC_MESSAGES/@[email protected]
		 
		# This is ok for maemo. Not sure in a regular desktop:
		APP_DIR = os.path.dirname(os.path.abspath(__file__) )
		LOCALE_DIR = os.path.join(APP_DIR, 'locale') # .mo files will then be located in APP_Dir/i18n/LANGUAGECODE/LC_MESSAGES/
		 
		# Now we need to choose the language. We will provide a list, and gettext
		# will use the first translation available in the list
		#
		#  In maemo it is in the LANG environment variable
		#  (on desktop is usually LANGUAGES)
		DEFAULT_LANGUAGES = os.environ.get('LANG', '').split(':')
		DEFAULT_LANGUAGES += ['en_US']
		 
		lc, encoding = locale.getdefaultlocale()
		if lc:
		    loc = [lc]
		 
		# Concat all languages (env + default locale),
		#  and here we have the languages and location of the translations
		loc += DEFAULT_LANGUAGES
		self.mo_location = LOCALE_DIR
		# Lets tell those details to gettext
		#  (nothing to change here for you)
		gettext.install(True, localedir=None, unicode=1)
		 
		gettext.find(APP_NAME, self.mo_location)
		 
		gettext.textdomain (APP_NAME)
		 
		gettext.bind_textdomain_codeset(APP_NAME, "UTF-8")
		self.language = gettext.translation(APP_NAME, self.mo_location, languages=loc, fallback=True)
Exemple #3
0
def main():
    """Main entry point for the script."""

# Set up message catalog access
    #t = gettext.translation('messages', './po', fallback=True)
    t = gettext.translation('messages', 'locale', ['en_US'])
    #_ = t.ugettext

    #gettext.bindtextdomain('messages', './po')
    #print gettext.bindtextdomain('messages')

    #gettext.textdomain('messages')
    #print gettext.textdomain()

    _ = t.gettext

    print _('test')
    print _('test-a')

    print gettext.find('messages')

    en_us = gettext.translation('messages', 'locale', languages=['en_US'])
    en_us.install()
    _ = en_us.gettext

    print _('test')
    print _('test-a')
    print en_us.gettext('test-a')
    print en_us.gettext('test-b')

    pass
Exemple #4
0
def get_translation(domain, modfile=None):
    """
    Initialize a translation domain. Unless modfile is supplied,
    the translation will be searched for in the default location. If it
    is supplied, it's parent directory will be pre-pended to i18n to get
    the location to use.
    
    Translation objects are cached.
    
    Keyword arguments:
    domain        --    translation domain
    modfile       --    module file location (search relative to this file + /i18n)
    """
    if domain in __translations:
        return __translations[domain]
    gettext.install (True, localedir=None, unicode=1)
    translation_location = mo_location
    if modfile is not None:
        translation_location = "%s/i18n" % os.path.dirname(modfile)
    gettext.find(domain, translation_location)
    locale.bindtextdomain(domain, translation_location)
    gettext.bindtextdomain(domain, translation_location)
    gettext.textdomain (domain)
    gettext.bind_textdomain_codeset(domain, "UTF-8")
    language = gettext.translation (domain, translation_location, languages=languages, fallback=True)
    __translations[domain] = language
    return language
Exemple #5
0
def CheckTranslationAvailability(lang):
    """Function that check the availabilty for a specified language"""

    # Package name for gettext
    PACKAGE = 'nicotine'

    # Local path where to find translation (mo) files
    LOCAL_MO_PATH = 'languages'

    # Message to return to the settingswindow if errors are found
    msg_alert = ""

    # We don't need checkr since the user wants the english language
    if lang == "en":
        return

    # We try to find the translation file in the current path
    if gettext.find(PACKAGE,
                    localedir=LOCAL_MO_PATH,
                    languages=[lang]
                    ) is None:

        # We try to find the translation file in the global path
        if gettext.find(PACKAGE, languages=[lang]) is None:

            msg_alert = _("Translation for '%s' not found.") % (lang)

    return msg_alert
Exemple #6
0
def _init_languages():
    """
    Create the gettext languages.

    @return the gettext object

    """

    # Get locals but ignore the encoding (2 arg).
    default_lc, _ = locale.getdefaultlocale()
    if default_lc:
        languages = [default_lc]

    # Concat all languages (env + default locale),
    #  and here we have the languages and location of the translations
    languages += DEFAULT_LANGUAGES
    mo_location = LOCALE_DIR

    # Lets tell those details to gettext
    #  (nothing to change here for you)
    gettext.install(True, localedir=None, unicode=1)

    gettext.find(APP_NAME, mo_location)

    gettext.textdomain(APP_NAME)

    gettext.bind_textdomain_codeset(APP_NAME, "UTF-8")

    return gettext.translation(APP_NAME, mo_location, languages=languages, fallback=True)
Exemple #7
0
    def _init (cls):
        def callback (widget, allocation):
            cls.widgets["enterGameNotationFrame"].set_size_request(
                    223, allocation.height-4)
        cls.widgets["enterGameNotationSidePanel"].connect_after("size-allocate", callback)

        flags = []
        if isInstalled():
            path = gettext.find("pychess")
        else:
            path = gettext.find("pychess", localedir=addDataPrefix("lang"))
        if path:
            loc = locale.getdefaultlocale()[0][-2:].lower()
            flags.append(addDataPrefix("flags/%s.png" % loc))

        flags.append(addDataPrefix("flags/us.png"))

        cls.ib = ImageButton(flags)
        cls.widgets["imageButtonDock"].add(cls.ib)
        cls.ib.show()

        cls.sourcebuffer = GtkSource.Buffer()
        sourceview = GtkSource.View.new_with_buffer(cls.sourcebuffer)
        sourceview.set_tooltip_text(
            _("Type or paste PGN game or FEN positions here"))
        cls.widgets["scrolledwindow6"].add(sourceview)
        sourceview.show()

        # Pgn format does not allow tabulator
        sourceview.set_insert_spaces_instead_of_tabs(True)
        sourceview.set_wrap_mode(Gtk.WrapMode.WORD)

        man = GtkSource.LanguageManager()
        # Init new version
        if hasattr(man.props, 'search_path'):
            try:
                path = os.path.join(getDataPrefix(),"gtksourceview-1.0/language-specs")
                man.props.search_path = man.props.search_path + [path]
                if 'pgn' in man.get_language_ids():
                    lang = man.get_language('pgn')
                    cls.sourcebuffer.set_language(lang)
                else:
                    log.warning("Unable to load pgn syntax-highlighting.")
                cls.sourcebuffer.set_highlight_syntax(True)
            except NotImplementedError:
                # Python 2.7.3 in Ubuntu 12.04
                log.warning("Unable to load pgn syntax-highlighting.")
        # Init old version
        else:
            os.environ["XDG_DATA_DIRS"] = getDataPrefix()+":/usr/share/"
            man = LanguageManager()
            for lang in man.get_available_languages():
                if lang.get_name() == "PGN":
                    cls.sourcebuffer.set_language(lang)
                    break
            else:
                log.warning("Unable to load pgn syntax-highlighting.")
            cls.sourcebuffer.set_highlight(True)
def add_translation():
    lc, enc = locale.getdefaultlocale()

    if os.path.exists(os.path.join(os.path.dirname(sys.argv[0]), "i18n")):
        # Running locally
        logging.debug("Running local")
        gettext.bindtextdomain("youtubed-2x", "i18n")
        lc, enc = locale.getdefaultlocale()
        lang = gettext.translation("youtubed-2x", "i18n", languages=[lc], fallback=True)
        logging.debug(lang)

        lang.install()
        # gettext.install ("youtubed-2x", "i18n")
        gtk.glade.bindtextdomain("youtubed-2x", "i18n")
    elif gettext.find("youtubed-2x"):
        # Installed. .mo file is in default locale location
        logging.debug("Found default locale")
        gettext.install("youtubed-2x")
        gtk.glade.bindtextdomain("youtubed-2x")
    elif WINDOWS and os.path.exists(os.path.join(sys.prefix, "share", "locale")):
        # Windows when using build made with Py2exe
        logging.debug("Py2exe build")
        locale_dir = os.path.join(sys.prefix, "share", "locale")
        gettext.bindtextdomain("youtubed-2x", locale_dir)
        lang = gettext.translation("youtubed-2x", locale_dir, languages=[lc], fallback=True)
        logging.debug(lang)
        lang.install()
        # gettext.install ("youtubed-2x", "i18n")
        gtk.glade.bindtextdomain("youtubed-2x", locale_dir)
    else:
        # Installed. Try to discover locale location
        logging.debug("Installed")
        locale_dir = None
        if "XDG_DATA_DIRS" in os.environ:
            data_dirs = os.environ["XDG_DATA_DIRS"].split(":")
            for data_dir in data_dirs:
                mofile = gettext.find("youtubed-2x", os.path.join(data_dir, "locale"))

                logging.debug(mofile)
                if mofile:
                    locale_dir = os.path.join(data_dir, "locale")
                    break

        logging.debug(locale_dir)
        if locale_dir:
            gettext.install("youtubed-2x", locale_dir)
            gtk.glade.bindtextdomain("youtubed-2x", locale_dir)
        else:
            # If .mo file could not be found, ignore the issue.
            # Non-translated strings will be used. Install _()
            # to global namespace
            gettext.install("youtubed-2x")
            gtk.glade.bindtextdomain("youtubed-2x")

    # gettext.install ("youtubed-2x")
    gtk.glade.textdomain("youtubed-2x")
    logging.debug(_)
 def test_cached_find(self):
     domain = 'my-unique-domain'
     key = (domain, None, None, 0)
     self.assertNotIn(key, _gettextutils._FIND_CACHE)
     gettext.find(domain)
     self.assertIn(key, _gettextutils._FIND_CACHE)
     _gettextutils._FIND_CACHE[key] = "spoof result"
     self.assertEqual("spoof result", gettext.find(domain))
     _gettextutils._FIND_CACHE.pop(key)
Exemple #10
0
    def i18n(self):
        import gettext
        import pylons
        import os.path

        # Repris de pylons.i18n.translation:_get_translator.
        conf = pylons.config.current_conf()
        try:
            rootdir = conf['pylons.paths']['root']
        except KeyError:
            rootdir = conf['pylons.paths'].get('root_path')
        localedir = os.path.join(rootdir, 'i18n')

        lang = get_lang()

        # Localise le fichier *.mo actuellement chargé
        # et génère le chemin jusqu'au *.js correspondant.
        filename = gettext.find(conf['pylons.package'], localedir,
            languages=lang)
        js = filename[:-3] + '.js'
        # Récupère et envoie le contenu du fichier de traduction *.js.
        fhandle = open(js, 'r')
        translations = fhandle.read()
        fhandle.close()

        # Même chose pour les thèmes
        themes_filename = gettext.find(
            'vigilo-themes',
            resource_filename('vigilo.themes.i18n', ''),
            languages=lang)
        themes_js = themes_filename[:-3] + '.js'
        fhandle = open(themes_js, 'r')
        translations += fhandle.read()
        fhandle.close()

        # Extensions Enterprise
        try:
            ent_filename = gettext.find(
                'vigilo-vigigraph-enterprise',
                resource_filename('vigilo.vigigraph_enterprise.i18n', ''),
                languages=lang)
        except ImportError:
            pass
        else:
            # Le nom du fichier sera None s'il n'existe pas
            # de traductions dans la langue demandée.
            if ent_filename is not None:
                fhandle = open(ent_filename[:-3] + '.js', 'r')
                translations += fhandle.read()
                fhandle.close()

        return translations
Exemple #11
0
    def __init__(self):
        # The translation files will be under
        # @locale_dir@/@LANGUAGE@/LC_MESSAGES/@[email protected]
        self.app_name = "innstereo"
        app_dir = abspath(os.path.dirname(__file__))

        # Locale are stored in innstereo/locale
        # .mo files will then be located in innstereo/locale/LANGUAGECODE/LC_MESSAGES/
        locale_dir = abspath(join(app_dir, "locale"))

        if sys.platform == "win32":
            # Set $LANG on MS Windows for gettext
            if os.getenv('LANG') is None:
                lang, enc = locale.getdefaultlocale() #lang is POSIX e.g. de_DE
                os.environ['LANG'] = lang
                languages = [lang]

            # Set LOCALE_DIR for MS Windows
            import ctypes
            LIB_INTL = abspath(join(app_dir, "../gnome/libintl-8.dll"))
            libintl = ctypes.cdll.LoadLibrary(LIB_INTL)
            lc = locale.setlocale(locale.LC_ALL, "")
            locale_dir_g = abspath(join(app_dir, "locale"))
            libintl.bindtextdomain(self.app_name, locale_dir_g)
            libintl.bind_textdomain_codeset(self.app_name, "UTF-8")
        else:
            kwargs = {}
            if sys.version < '3':
                kwargs['unicode'] = 1
            gettext.install(True, localedir=None, **kwargs)

            gettext.find(self.app_name, locale_dir)
            locale.bindtextdomain(self.app_name, locale_dir)

        # Now we need to choose the language. We will provide a list, and gettext
        # will use the first translation available in the list
        default_languages = os.environ.get('LANG', '').split(':')
        default_languages += ['en_US']

        lc, encoding = locale.getdefaultlocale()
        if lc:
            languages = [lc]

        # Concat all languages (env + default locale),
        # and here we have the languages and location of the translations
        languages += default_languages

        gettext.bindtextdomain (self.app_name, locale_dir)
        gettext.textdomain (self.app_name)

        self._language = gettext.translation(self.app_name, locale_dir,
                                             languages=languages, fallback=True)
Exemple #12
0
def get_translations():
    """ Search the Application directory and the Flask-User directory for the
        Flask-User translations file and return a Translations() object."""
    ctx = _request_ctx_stack.top
    if ctx is None:
        return None
    translations = getattr(ctx, 'flask_user_translations', None)
    if translations is None:
        # Prepare settings
        domain = 'flask_user'
        locales = [get_locale()]
        languages = [str(locale) for locale in locales]
        # Search Application directory
        app_dir = os.path.join(current_app.root_path, 'translations')
        filename = python_gettext.find(domain, app_dir, languages)
        if filename:
            translations = support.Translations.load(app_dir, locales, domain=domain)
        else:
            # Search Flask-User directory
            flask_user_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'translations')
            translations = support.Translations.load(flask_user_dir, locales, domain=domain)

        ctx.flask_user_translations = translations

    return ctx.flask_user_translations
    def load(cls, dirname=None, locales=None, domain=DEFAULT_DOMAIN):
        """Load translations from the given directory.

        :param dirname: the directory containing the ``MO`` files
        :param locales: the list of locales in order of preference (items in
        this list can be either `Locale` objects or locale
        strings)
        :param domain: the message domain
        :return: the loaded catalog, or a ``NullTranslations`` instance if no
        matching translations were found
        :rtype: `Translations`
        """
        if locales is not None:
            if not isinstance(locales, (list, tuple)):
                locales = [locales]
            locales = [str(l) for l in locales]
        if not domain:
            domain = cls.DEFAULT_DOMAIN
        filename = gettext.find(domain, dirname, locales)
        import pytest
        pytest.set_trace()
        if not filename:
            return gettext.NullTranslations()
        with open(filename, 'rb') as fp:
            return cls(fileobj=fp, domain=domain)
Exemple #14
0
def rebuild_database(pathname, debian_sources=True, appstream_sources=False):
    #cache = apt.Cache(memonly=True)
    cache = get_pkg_info()
    cache.open()
    old_path = pathname+"_old"
    rebuild_path = pathname+"_rb"
    
    if not os.path.exists(rebuild_path):
        try:
            os.makedirs(rebuild_path)
        except:
            LOG.warn("Problem creating rebuild path '%s'." % rebuild_path)
            LOG.warn("Please check you have the relevant permissions.")
            return False
    
    # check permission
    if not os.access(pathname, os.W_OK):
        LOG.warn("Cannot write to '%s'." % pathname)
        LOG.warn("Please check you have the relevant permissions.")
        return False
    
    #check if old unrequired version of db still exists on filesystem
    if os.path.exists(old_path):
        LOG.warn("Existing xapian old db was not previously cleaned: '%s'." % old_path)
        if os.access(old_path, os.W_OK):
            #remove old unrequired db before beginning
            shutil.rmtree(old_path)
        else:
            LOG.warn("Cannot write to '%s'." % old_path)
            LOG.warn("Please check you have the relevant permissions.")
            return False

            
    # write it
    db = xapian.WritableDatabase(rebuild_path, xapian.DB_CREATE_OR_OVERWRITE)

    if debian_sources:
        update(db, cache)
    if appstream_sources:
        update_from_appstream_xml(db, cache)

    # write the database version into the filep
    db.set_metadata("db-schema-version", DB_SCHEMA_VERSION)
    # update the mo file stamp for the langpack checks
    mofile = gettext.find("app-install-data")
    if mofile:
        mo_time = os.path.getctime(mofile)
        db.set_metadata("app-install-mo-time", str(mo_time))
    db.flush()
    
    # use shutil.move() instead of os.rename() as this will automatically
    # figure out if it can use os.rename or needs to do the move "manually"
    try:
        shutil.move(pathname, old_path)
        shutil.move(rebuild_path, pathname)
        shutil.rmtree(old_path)
        return True
    except:
        LOG.warn("Cannot copy refreshed database to correct location: '%s'." % pathname)
        return False
def get_available_languages(domain):
    """Lists the available languages for the given translation domain.

    :param domain: the domain to get languages for
    """
    if domain in _AVAILABLE_LANGUAGES:
        return copy.copy(_AVAILABLE_LANGUAGES[domain])

    localedir = '%s_LOCALEDIR' % domain.upper()
    find = lambda x: gettext.find(domain,
                                  localedir=os.environ.get(localedir),
                                  languages=[x])

    # NOTE(mrodden): en_US should always be available (and first in case
    # order matters) since our in-line message strings are en_US
    language_list = ['en_US']
    # NOTE(luisg): Babel <1.0 used a function called list(), which was
    # renamed to locale_identifiers() in >=1.0, the requirements master list
    # requires >=0.9.6, uncapped, so defensively work with both. We can remove
    # this check when the master list updates to >=1.0, and all projects udpate
    list_identifiers = (getattr(localedata, 'list', None) or
                        getattr(localedata, 'locale_identifiers'))
    locale_identifiers = list_identifiers()
    for i in locale_identifiers:
        if find(i) is not None:
            language_list.append(i)
    _AVAILABLE_LANGUAGES[domain] = language_list
    return copy.copy(language_list)
Exemple #16
0
def get_i18n_json(domain=app, localedir=None, languages=None):
    try:
        mofile = gettext.find(domain, localedir, languages)
        translations = gettext.GNUTranslations(open(mofile, 'rb'))
        return json.dumps(translations._catalog, ensure_ascii=0)
    except:
        return '{}'
Exemple #17
0
def initlocalization():
	gettext.textdomain("brita")

	filename = gettext.find("brita")
	if filename == None:
		filename = gettext.find("brita", "build/mo")

	try:
		if filename != None:
			trans = gettext.GNUTranslations(open(filename, "rb"))
		else:
			trans = gettext.NullTranslations()
	except IOError:
		trans = gettext.NullTranslations()

	trans.install()
Exemple #18
0
def get_available_languages():
    # Magic paths copied from pylons.i18n.translation._get_translator
    localedir = os.path.join(config['pylons.paths']['root'], 'i18n')
    messagefiles = gettext.find(config['pylons.package'], localedir,
                                languages=babel.Locale('en').languages.keys(),
                                all=True)
    return [path.split('/')[-3] for path in messagefiles]
Exemple #19
0
def get_available_languages(domain):
    """Lists the available languages for the given translation domain.

    :param domain: the domain to get languages for
    """
    if domain in _AVAILABLE_LANGUAGES:
        return copy.copy(_AVAILABLE_LANGUAGES[domain])

    localedir = os.environ.get(_locale.get_locale_dir_variable_name(domain))
    find = lambda x: gettext.find(domain,
                                  localedir=localedir,
                                  languages=[x])

    # NOTE(mrodden): en_US should always be available (and first in case
    # order matters) since our in-line message strings are en_US
    language_list = ['en_US']
    locale_identifiers = localedata.locale_identifiers()
    language_list.extend(language for language in locale_identifiers
                         if find(language))

    # In Babel 1.3, locale_identifiers() doesn't list some OpenStack supported
    # locales (e.g. 'zh_CN', and 'zh_TW') so we add the locales explicitly if
    # necessary so that they are listed as supported.
    aliases = {'zh': 'zh_CN',
               'zh_Hant_HK': 'zh_HK',
               'zh_Hant': 'zh_TW',
               'fil': 'tl_PH'}

    language_list.extend(alias for locale, alias in six.iteritems(aliases)
                         if (locale in language_list and
                             alias not in language_list))

    _AVAILABLE_LANGUAGES[domain] = language_list
    return copy.copy(language_list)
Exemple #20
0
 def _traductions_disponibles(self):
         global debug
         lst_lang = []
         try:
                 # Par défaut on essaye d'utiliser la langue désignée par la variable d'environement $LANG
                 env_lang = os.environ["LANG"]
                 if ("_" in env_lang):
                     env_lang = env_lang.split('_')[0]
                 if debug:
                         print "LANG=%s (environnement)" % (env_lang)
                 lst_lang.append(env_lang)
                 # Recherche dans l'arborescence standard des fichier de traduction ($lang/LC_MESSAGES/nom_appli.mo)
                 lst_trad = []
                 for lang in os.listdir(self.rep_trad):
                         if os.path.isdir(os.path.join(self.rep_trad,lang)) and lang != self.source_lang and lang != env_lang:
                                 if debug:
                                         print "the directorie %s/LC_MESSAGES exist" % (lang)
                                 lst_trad.append(lang)
                 for trad in gettext.find(self.appli, self.rep_trad, languages=lst_trad, all=True):
                         if trad != self.source_lang and trad != env_lang:
                                 if debug:
                                         print "Other available language, found valid .mo : %s)" % (trad)
                                 lst_lang.append(trad.split("/",2)[1:2][0])
                 # En dernier recours on utilise la langue originale du programme source (fallback)
                 if self.source_lang != env_lang:
                         lst_lang.append(self.source_lang)
         except Exception:
                 print "%s : ERROR : %s" % (sys.argv[0], err)
         finally:
             if debug:
                 print "Available langs list : %s" % (lst_lang)
             return lst_lang
Exemple #21
0
    def __init__(self, argparser):
        from gramps.gen.dbstate import DbState
        from . import viewmanager
        from .viewmanager import ViewManager
        from gramps.cli.arghandler import ArgHandler
        from .tipofday import TipOfDay
        from .dialog import WarningDialog
        import gettext

        _display_welcome_message()

        # Append image directory to the theme search path
        theme = Gtk.IconTheme.get_default()
        theme.append_search_path(IMAGE_DIR)

        if lin() and glocale.lang != 'C' and not gettext.find(GTK_GETTEXT_DOMAIN):
            LOG.warn("GTK translations missing, GUI will be broken, especially for RTL languages!")
            # Note: the warning dialog below will likely have wrong stock icons!
            # Translators: the current language will be the one you translate into.
            WarningDialog(
               _("Gramps detected an incomplete GTK installation"),
               _("GTK translations for the current language (%(language)s) "
                 "are missing.\n%(bold_start)sGramps%(bold_end)s will "
                 "proceed nevertheless.\nThe GUI will likely be broken "
                 "as a result, especially for RTL languages!\n\n"
                 "See the Gramps README documentation for installation "
                 "prerequisites,\ntypically located in "
                 "/usr/share/doc/gramps.\n") % {
                     'language'   : glocale.lang ,
                     'bold_start' : '<b>' ,
                     'bold_end'   : '</b>' } )

        dbstate = DbState()
        self.vm = ViewManager(dbstate,
                config.get("interface.view-categories"))
        self.vm.init_interface()

        #act based on the given arguments
        ah = ArgHandler(dbstate, argparser, self.vm, self.argerrorfunc,
                        gui=True)
        ah.handle_args_gui()
        if ah.open or ah.imp_db_path:
            # if we opened or imported something, only show the interface
            self.vm.post_init_interface(show_manager=False)
        elif config.get('paths.recent-file') and config.get('behavior.autoload'):
            # if we need to autoload last seen file, do so
            filename = config.get('paths.recent-file')
            if os.path.isdir(filename) and \
                    os.path.isfile(os.path.join(filename, "name.txt")) and \
                    ah.check_db(filename):
                self.vm.post_init_interface(show_manager=False)
                self.vm.open_activate(filename)
            else:
                self.vm.post_init_interface()
        else:
            # open without fam tree loaded
            self.vm.post_init_interface()

        if config.get('behavior.use-tips'):
            TipOfDay(self.vm.uistate)
Exemple #22
0
 def i18n(self, domain="main", language=None):
     """
     Provides module based localization.
     Domain is a path relative to SelfPath that specifies the location
     of the translation catalog. ".." or "../.." or example.
     Language is the language to use.  Really?  Yes.
     """
     source_append = ""
     if domain:
         domain = os.path.basename(domain)
         source_append = os.path.dirname(domain)
     elif self.__i18n_domain__:
         domain = os.path.basename(self.__i18n_domain__)
         source_append = os.path.dirname(self.__i18n_domain__)
     else:
         domain = self.__class__.__name__.lower()
     if not language:
         language = self.__i18n_language__
     sources = [
         os.path.join(self.get_exec_path(), source_append),
         os.path.join(self.get_lib_path(), source_append),
         os.path.join(os.path.dirname(self.get_self_path()), source_append)]
     for i, s in enumerate(sources):
         sources[i] = os.path.abspath(s)
     for i, s in enumerate(sources):
         sources[i] = os.path.join(s, "locale")
     sources_ = []
     for source in sources:
         if source not in sources_:
             sources_.append(source)
     for source in sources:
         if gettext.find(domain, source, [language]):
             return gettext.translation(domain, source, [language]).ugettext
     return gettext.translation(domain, fallback=True).ugettext
Exemple #23
0
    def _get_translation(self, domain = None,
                         localedir = None,
                         languages=None):
        """
        Get a translation of one of our classes. Doesn't return the
        singleton so that it can be used by get_addon_translation()
        """
        if not domain:
            domain = self.localedomain
        if not languages:
            languages = self.language
        if not localedir:
            localedir = self.localedir

        for lang in languages:
            if gettext.find(domain, localedir, [lang]):
                translator = gettext.translation(domain, localedir,
                                                 [lang],
                                                 class_ = WearNowTranslations)
                translator._language = lang
                return translator

            elif lang.startswith("en") or lang.startswith("C"):
                translator = WearNowNullTranslations()
                translator._language = "en"
                return translator

        if not languages or len(languages) == 0:
            LOG.warning("No language provided, using US English")
        else:
            raise ValueError("No usable translations in %s for " %
                             ':'.join(languages))
        translator = WearNowNullTranslations()
        translator._language = "en"
        return translator
Exemple #24
0
def check_language(lang_code):
    "Check existance of language files"
    if gettext.find('baruwa', I18NPATH, [lang_code]) is not None:
        lang_list = extract_languages()
        if lang_list and lang_code not in lang_list:
            return False
        return True
    return False
Exemple #25
0
 def setUp(self):
     localedir = os.path.join(configure.localedatadir, 'locale')
     mo = gettext.find(configure.PACKAGE, localedir, ["nl_NL"])
     self.failUnless(mo)
     self.nl = gettext.translation(configure.PACKAGE, localedir, ["nl_NL"])
     self.failUnless(self.nl)
     self.able = N_("I am a translatable string")
     self.ed = self.nl.gettext("I am a translated string")
def set_available_locales():
    """Set available locales for which we have translations"""
    global AVAILABLE_LOCALES
    locales=['en', 'en_US'] # these are available without translations
    for locale in localedata.list():
        if gettext.find('mediagoblin', TRANSLATIONS_PATH, [locale]):
            locales.append(locale)
    AVAILABLE_LOCALES = locales
Exemple #27
0
def find_catalog_files(docname, srcdir, locale_dirs, lang, compaction):
    if not (lang and locale_dirs):
        return []

    domain = find_catalog(docname, compaction)
    files = [gettext.find(domain, path.join(srcdir, dir_), [lang]) for dir_ in locale_dirs]
    files = [path.relpath(f, srcdir) for f in files if f]
    return files
Exemple #28
0
def set_language(lang):
    __get__logger().debug("Trying to set language to %s", lang)
    languages.clear()
    languages.append(lang)

    __get__logger().debug(gettext.find(APP_NAME, LOCALE_DIR, languages=[lang]))
    gettext.translation(APP_NAME, LOCALE_DIR, languages=[lang], fallback=True).install()
    __get__logger().debug("Ready setting language to %s", lang)
Exemple #29
0
def test_iso_codes():
    import gettext
    languages = (lang[0] for lang in settings.LANGUAGES)
    if not languages:
        # There are no UI languages, which is a problem, but we won't complain
        # about that here.
        languages = ['af', 'ar', 'fr']
    return len(gettext.find('iso_639', languages=languages, all=True)) > 0
Exemple #30
0
def get_language_from_request(request):
    """
    Analyzes the request to find what language the user wants the system to show.
    Only languages listed in settings.LANGUAGES are taken into account. If the user
    requests a sublanguage where we have a main language, we send out the main language.
    """
    global _accepted
    from django.conf import settings
    globalpath = os.path.join(os.path.dirname(sys.modules[settings.__module__].__file__), 'locale')
    supported = dict(settings.LANGUAGES)

    if hasattr(request, 'session'):
        lang_code = request.session.get('django_language', None)
        if lang_code in supported and lang_code is not None and check_for_language(lang_code):
            return lang_code

    lang_code = request.COOKIES.get('django_language', None)
    if lang_code in supported and lang_code is not None and check_for_language(lang_code):
        return lang_code

    accept = request.META.get('HTTP_ACCEPT_LANGUAGE', None)
    if accept is not None:

        t = _accepted.get(accept, None)
        if t is not None:
            return t

        def _parsed(el):
            p = el.find(';q=')
            if p >= 0:
                lang = el[:p].strip()
                order = int(float(el[p+3:].strip())*100)
            else:
                lang = el
                order = 100
            p = lang.find('-')
            if p >= 0:
                mainlang = lang[:p]
            else:
                mainlang = lang
            return (lang, mainlang, order)

        langs = [_parsed(el) for el in accept.split(',')]
        langs.sort(lambda a,b: -1*cmp(a[2], b[2]))

        for lang, mainlang, order in langs:
            if lang in supported or mainlang in supported:
                langfile = gettext_module.find('django', globalpath, [to_locale(lang)])
                if langfile:
                    # reconstruct the actual language from the language
                    # filename, because otherwise we might incorrectly
                    # report de_DE if we only have de available, but
                    # did find de_DE because of language normalization
                    lang = langfile[len(globalpath):].split(os.path.sep)[1]
                    _accepted[accept] = lang
                    return lang

    return settings.LANGUAGE_CODE
Exemple #31
0
def initLocalization(settings):
    import gettext
    import os
    localeDir = os.path.join(os.getcwd(), 'locales')

    curLang = settings['lang']

    #gettext.bindtextdomain('bibledave', localeDir )
    #gettext.textdomain('bibledave')
    #gettext.install('bibledave', localeDir)
    # print gettext.textdomain(),gettext.bindtextdomain('bibledave')

    language = [languages[curLang]]

    l = gettext.find('bibledave', localeDir, language)
    if l == None:
        raise "No language file found for language", curLang

    t = gettext.translation('bibledave', localeDir, language)
    t.install()
Exemple #32
0
def get_locale_dir():
    if os.name == 'nt':
        return None
    # try to find domain in localedir
    path = gettext.find(DOMAIN)
    if path:
        # extract localedir from localedir/language/LC_MESSAGES/domain.mo
        path, tail = os.path.split(path)
        path, tail = os.path.split(path)
        localedir, tail = os.path.split(path)
    elif os.path.exists('/app/share/run-as-flatpak'):
        # Check if we run as flatpak
        return '/app/share/locale'
    else:
        # fallback to user locale
        base = os.getenv('XDG_DATA_HOME')
        if base is None or base[0] != '/':
            base = os.path.expanduser('~/.local/share')
        localedir = os.path.join(base, "locale")
    return localedir
Exemple #33
0
    def load(cls, dirname=None, locales=None, domain=None):
        """Load translations from the given directory.

        :param dirname: the directory containing the ``MO`` files
        :param locales: the list of locales in order of preference (items in
                        this list can be either `Locale` objects or locale
                        strings)
        :param domain: the message domain (default: 'messages')
        """
        if locales is not None:
            if not isinstance(locales, (list, tuple)):
                locales = [locales]
            locales = [str(locale) for locale in locales]
        if not domain:
            domain = cls.DEFAULT_DOMAIN
        filename = gettext.find(domain, dirname, locales)
        if not filename:
            return NullTranslations()
        with open(filename, 'rb') as fp:
            return cls(fp=fp, domain=domain)
Exemple #34
0
    def get_translation_for(package_name): # type: (str) -> gettext.NullTranslations
        '''Find and return gettext translation for package
        (Try to find folder manually if setuptools does not exist)
        '''

        if '.' in package_name:
            package_name = '.'.join(package_name.split('.')[:-1])
        localedir = None

        if pkg_resources is None:
            mydir = os.path.join(local_dir, 'i18n')
        else:
            mydir = pkg_resources.resource_filename(package_name, 'i18n')

        for localedir in mydir, None:
            localefile = gettext.find(package_name, localedir)
            if localefile:
                break

        return gettext.translation(package_name, localedir=localedir, fallback=True)
Exemple #35
0
    def __init__(self, locale, version):
        self.pot = POFile(check_for_duplicate=True)
        self.pot.metadata = {
            'Project-Id-Version': version,
            'POT-Creation-Date': str(datetime.now()),
            'MIME-Version': '1.0',
            'Content-Type': 'text/plain; charset=utf-8',
        }

        (Path('.') / 'locale').mkdir(exist_ok=True)
        self.languages = locale.split('+')
        for lang in self.languages:
            if gettext.find('content',
                            localedir=Path('.') / 'locale',
                            languages=[lang]) is None:
                mo_path = Path(
                    '.') / 'locale' / lang / 'LC_MESSAGES' / 'content.mo'
                po_path = Path(
                    '.') / 'locale' / lang / 'LC_MESSAGES' / 'content.po'
                if po_path.exists():
                    print(
                        f'The file "{str(mo_path)}" not found.\nUsing "{str(po_path)}" instead.'
                    )
                    pofile(po_path).save_as_mofile(mo_path)
                    print(f'"{str(mo_path)}" generated.')
                else:
                    print(
                        f'The file "{str(mo_path)}" or "{str(po_path)}" not found.'
                    )
                    print(f'Using the original Lean files for "{lang}".\n')
            self.translations = [
                gettext.translation('content',
                                    localedir=Path('.') / 'locale',
                                    languages=[lang],
                                    fallback=True) for lang in self.languages
            ]

        self.original_texts = []
        self.translated_texts = [[] for lang in self.languages]

        self.occ = None
Exemple #36
0
def _get_translator(lang, tgl=None, tg_config=None, **kwargs):
    """Utility method to get a valid translator object from a language name"""
    if tg_config:
        conf = tg_config
    else:
        if tgl:
            conf = tgl.config
        else:  # pragma: no cover
            #backward compatibility with explicit calls without
            #specifying local context or config.
            conf = tg.config.current_conf()

    if not lang:
        return NullTranslations()

    try:
        localedir = conf['localedir']
    except KeyError:  # pragma: no cover
        localedir = os.path.join(conf['paths']['root'], 'i18n')
    app_domain = conf['package'].__name__

    if not isinstance(lang, list):
        lang = [lang]

    mofiles = []
    supported_languages = []
    for l in lang:
        mo = _gettext.find(app_domain, localedir=localedir, languages=[l], all=False)
        if mo is not None:
            mofiles.append(mo)
            supported_languages.append(l)

    try:
        translator = _translator_from_mofiles(app_domain, mofiles, **kwargs)
    except IOError as ioe:
        raise LanguageError('IOError: %s' % ioe)

    translator.tg_lang = lang
    translator.tg_supported_lang = supported_languages

    return translator
Exemple #37
0
def get_translations():
    # If there is no context:  return None
    ctx = _request_ctx_stack.top
    if not ctx:
        return None

    # If context exists and contains a cached value, return cached value
    if hasattr(ctx, 'flask_user_translations'):
        return ctx.flask_user_translations

    # If App has not initialized Flask-Babel: return None
    app_has_initalized_flask_babel = 'babel' in current_app.extensions
    if not app_has_initalized_flask_babel:  # pragma no cover
        ctx.flask_user_translations = None
        return ctx.flask_user_translations

    # Prepare search properties
    import os
    import gettext as python_gettext
    from flask_babel import get_locale, get_translations, support
    domain = 'flask_user'
    locales = [get_locale()]
    languages = [str(locale) for locale in locales]

    # See if translations exists in Application dir
    app_dir = os.path.join(current_app.root_path, 'translations')
    filename = python_gettext.find(domain, app_dir, languages)
    if filename:
        ctx.flask_user_translations = support.Translations.load(app_dir,
                                                                locales,
                                                                domain=domain)

    # See if translations exists in Flask-User dir
    else:
        flask_user_dir = os.path.join(
            os.path.dirname(os.path.realpath(__file__)), 'translations')
        ctx.flask_user_translations = support.Translations.load(flask_user_dir,
                                                                locales,
                                                                domain=domain)

    return ctx.flask_user_translations.merge(get_translations())
Exemple #38
0
    def on_event(self, event, extension):
        # Set language
        language = self.preferences['main_language']
        domain = 'base'
        local_path = os.path.join(os.path.dirname(__file__), 'locales')
        logger.debug(
            f'Extension language is: {language}. Searching translation files in {local_path}.'
        )
        # Only translate if need to
        if language != 'en':
            if language in self.LANGUAGES:
                translation_file_path = gettext.find(domain, local_path,
                                                     [language])
                logger.debug(f'Translation file path: {translation_file_path}')
                try:
                    translator = gettext.translation(domain=domain,
                                                     localedir=local_path,
                                                     languages=[language])
                    translator.install()
                except FileNotFoundError:
                    logger.debug(
                        'Translation file not found. Go with default.')
                else:
                    global _
                    _ = translator.gettext

        # distribute events to proper listeners
        if extension is not self:
            raise RuntimeError('Something is very wrong.')
        if isinstance(event, KeywordQueryEvent):
            return self.on_keyword_query(event.get_keyword(),
                                         event.get_argument())
        if isinstance(event, ItemEnterEvent):
            return self.on_item_enter(event.get_data())
        if isinstance(event, SystemExitEvent):
            return self.on_system_exit()
        if isinstance(event, PreferencesEvent):
            return self.on_preferences(event.preferences)
        if isinstance(event, PreferencesUpdateEvent):
            return self.on_preferences_update(event.id, event.old_value,
                                              event.new_value)
Exemple #39
0
 def _gettext_instance(self, domain, origin):
     """tries to find locale using 1/ self._path, 2/ config.Config.translation,
     3/ system-wide place for locale"""
     import gettext, config
     # paths to try
     paths = [config.Config.translation_dir, None]
     if domain in self._path:
         paths.insert(0, self._path[domain])
     for path in paths:
         if gettext.find(domain, localedir=path, languages=[self._lang]):
             return gettext.translation(domain,
                                        localedir=path,
                                        languages=[self._lang])
     # The MO file was not found.
     paths[-1] = "System_defined_locale_dir"
     msg = "Translation file not found in paths: '%s', lang: '%s', origin: '%s'" % (
         ", ".join(paths), self._lang, origin)
     if self._fallback or self._lang == origin:
         return gettext.NullTranslations()
     else:
         raise IOError(msg)
Exemple #40
0
def i18n_catalog(context, request):
    current_language = locale_language = request._LOCALE_
    plural = None
    catalog = {}
    catalog_js = 'gecoscc_js'
    locale_path = os.path.join(os.sep.join(str(gecoscc.__file__).split(os.sep)[:-1]), 'locale')
    if not gettext_module.find(catalog_js, locale_path, [current_language]):
        settings = get_current_registry().settings
        locale_language = settings['pyramid.default_locale_name']
    # Inspirated by https://github.com/django/django/blob/master/django/views/i18n.py#L192
    t = gettext_module.translation(catalog_js, locale_path, [locale_language])._catalog
    if '' in t:
        for l in t[''].split('\n'):
            if l.startswith('Plural-Forms:'):
                plural = l.split(':', 1)[1].strip()
    if plural is not None:
        # this should actually be a compiled function of a typical plural-form:
        # Plural-Forms: nplurals=3; plural=n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2;
        plural = [el.strip() for el in plural.split(';') if el.strip().startswith('plural=')][0].split('=', 1)[1]

    pdict = {}
    maxcnts = {}
    for k, v in list(t.items()):
        if k == '':
            continue
        if isinstance(k, six.string_types):
            catalog[k] = v
        elif isinstance(k, tuple):
            msgid = k[0]
            cnt = k[1]
            maxcnts[msgid] = max(cnt, maxcnts.get(msgid, 0))
            pdict.setdefault(msgid, {})[cnt] = v
        else:
            raise TypeError(k)
    for k, v in list(pdict.items()):
        catalog[k] = [v.get(i, '') for i in range(maxcnts[msgid] + 1)]

    request.response.headers['Content-Type'] = 'text/javascript'
    return {'catalog': json.dumps(catalog),
            'plural': json.dumps(plural)}
Exemple #41
0
def set_lang(lang=None, localedir=None):
    """Set the locale"""

    global _translation, _lang

    # setup language preference order
    languages = []

    # default language from environment
    deflang, defencoding = locale.getdefaultlocale()
    if deflang:
        languages = [deflang + "." + defencoding] + languages

    # specified language
    if lang:
        languages = [lang] + languages

    # initialize gettext
    if localedir is None:
        localedir = _locale_dir
    gettext.bindtextdomain(GETTEXT_DOMAIN, localedir)
    gettext.textdomain(GETTEXT_DOMAIN)

    # search for language file
    langfile = gettext.find(GETTEXT_DOMAIN, localedir, languages)

    # setup language translations
    if langfile:
        _lang = os.path.basename(os.path.dirname(os.path.dirname(langfile)))
        set_env("LANG", _lang)
        set_env("LANGUAGE", _lang)
        _translation = gettext.GNUTranslations(open(langfile, "rb"))
    else:
        _lang = ""
        set_env("LANG", _lang)
        set_env("LANGUAGE", _lang)
        _translation = gettext.NullTranslations()

    # install "_" into python builtins
    _translation.install()
    def load(cls, dirname=None, locales=None, domain=DEFAULT_DOMAIN):
        """Load translations from the given directory.

        :param dirname: the directory containing the ``MO`` files
        :param locales: the list of locales in order of preference (items in
                        this list can be either `Locale` objects or locale
                        strings)
        :param domain: the message domain
        :return: the loaded catalog, or a ``NullTranslations`` instance if no
                 matching translations were found
        :rtype: `Translations`
        """
        if locales is not None:
            if not isinstance(locales, (list, tuple)):
                locales = [locales]
            locales = [str(locale) for locale in locales]
        if not domain:
            domain = cls.DEFAULT_DOMAIN
        filename = gettext.find(domain, dirname, locales)
        if not filename:
            return gettext.NullTranslations()
        return cls(fileobj=open(filename, 'rb'), domain=domain)
Exemple #43
0
def get_installed_translations():
    #
    # returns a list of translated installed languages, (de, es)...
    # and a list of lang/country combos for that language (de_DE, de_AT)...
    #
    import locale
    import gettext
    la_list = []
    la_co_list = []

    for (ident, la_co) in locale.windows_locale.iteritems():
        if gettext.find("fpdb", localedir="locale", languages=[la_co]):
            if "_" in la_co:
                la, co = la_co.split("_", 1)
                la_list.append(la)
            else:
                la_list.append(la_co)
            la_co_list.append(la_co)
    #
    #eliminate dupes
    #
    la_set = set(la_list)
    la_list = list(la_set)

    la_dict = {}
    la_co_dict = {}
    try:
        from icu import Locale
        for code in la_list:
            la_dict[code] = Locale.getDisplayName(Locale(code))
        for code in la_co_list:
            la_co_dict[code] = Locale.getDisplayName(Locale(code))
    except:
        for code in la_list:
            la_dict[code] = code
        for code in la_co_list:
            la_co_dict[code] = code

    return la_dict, la_co_dict
Exemple #44
0
 def _traductions_disponibles(self):
     global debug
     lst_lang = []
     try:
         # Par défaut on essaye d'utiliser la langue désignée par la variable d'environement $LANG
         env_lang = os.environ["LANG"]
         if ("_" in env_lang):
             env_lang = env_lang.split('_')[0]
         if debug:
             print "LANG=%s (environnement)" % (env_lang)
         lst_lang.append(env_lang)
         # Recherche dans l'arborescence standard des fichier de traduction ($lang/LC_MESSAGES/nom_appli.mo)
         lst_trad = []
         for lang in os.listdir(self.rep_trad):
             if os.path.isdir(
                     os.path.join(self.rep_trad, lang)
             ) and lang != self.source_lang and lang != env_lang:
                 if debug:
                     print "the directorie %s/LC_MESSAGES exist" % (lang)
                 lst_trad.append(lang)
         for trad in gettext.find(self.appli,
                                  self.rep_trad,
                                  languages=lst_trad,
                                  all=True):
             if trad != self.source_lang and trad != env_lang:
                 if debug:
                     print "Other available language, found valid .mo : %s)" % (
                         trad)
                 lst_lang.append(trad.split("/", 2)[1:2][0])
         # En dernier recours on utilise la langue originale du programme source (fallback)
         if self.source_lang != env_lang:
             lst_lang.append(self.source_lang)
     except Exception:
         print "%s : ERROR : %s" % (sys.argv[0], err)
     finally:
         if debug:
             print "Available langs list : %s" % (lst_lang)
         return lst_lang
Exemple #45
0
def _translation(path, lang, cache=None):
    '''
    Gets a translation for the given language from the locale path.
    '''
    if cache is None:
        cache = _cache[path]
    trans = cache.get(lang)
    if trans:
        return trans
    mofiles = gt.find(config.NAME, path, [lang], True)
    for mofile in mofiles:
        lg = _language(path, mofile)
        tn = cache.get(lg)
        if tn is None:
            tn = cache.setdefault(lg, gt.GNUTranslations(open(mofile, 'rb')))
            tn.set_output_charset(constants.ENCODING)
        if trans:
            trans.add_fallback(tn)
        else:
            trans = tn
    if trans is None:
        trans = gt.NullTranslations()
    return cache.setdefault(lang, trans)
Exemple #46
0
    def setup(application_name, locale_dir, app_code, app_messages):
        """Install the error handler
        :param application_name: It's the application name. It's used to set the domain. 
        :param locale_dir: It's the folder where are located the .po files. Usually APP_FOLDER/i18n/
        :param app_messages: Your application messages
        :param app_code: Application code"""
        if application_name is None or application_name == "":
            return (False, 'Application name must be set')

        if locale_dir is None or locale_dir == "" or not os.path.exists(
                locale_dir):
            return (False, 'Locale dir doesn\'t exists')
        AlienvaultMessageHandler.ERROR_MESSAGE_HASH = app_messages
        AlienvaultMessageHandler.APP_NAME = application_name
        AlienvaultMessageHandler.LOCALE_DIR = locale_dir
        AlienvaultMessageHandler.LANGUAGES = AlienvaultMessageHandler.__get_languages(
        )
        AlienvaultMessageHandler.APP_CODE = app_code

        gettext.install(True, localedir=None, unicode=True)
        current_language = 'en_US'
        for language in AlienvaultMessageHandler.LANGUAGES:
            if gettext.find(
                    AlienvaultMessageHandler.APP_NAME,
                    AlienvaultMessageHandler.LOCALE_DIR,
                    languages=AlienvaultMessageHandler.LANGUAGES) is not None:
                current_language = language
        # Set the text domain
        gettext.textdomain(AlienvaultMessageHandler.APP_NAME)
        gettext.bind_textdomain_codeset(AlienvaultMessageHandler.APP_NAME,
                                        "UTF-8")
        AlienvaultMessageHandler.CURRENT_LANGUAGE = gettext.translation(
            AlienvaultMessageHandler.APP_NAME,
            AlienvaultMessageHandler.LOCALE_DIR,
            languages=current_language,
            fallback=True)
        return (True, 'OK')
Exemple #47
0
    def get_translation_for(
            package_name: str
    ) -> gettext.NullTranslations:  # type: ignore[misc]
        """Find and return gettext translation for package
        (Try to find folder manually if setuptools does not exist)
        """

        if "." in package_name:
            package_name = ".".join(package_name.split(".")[:-1])
        localedir = None

        if pkg_resources is None:
            mydir = os.path.join(local_dir, "i18n")
        else:
            mydir = pkg_resources.resource_filename(package_name, "i18n")

        for localedir in mydir, None:
            localefile = gettext.find(package_name, localedir)
            if localefile:
                break

        return gettext.translation(package_name,
                                   localedir=localedir,
                                   fallback=True)
Exemple #48
0
def _get_languages():

    languages = []
    processed_catalogs = set([])
    # sorted() here is important to make processed_catalogs checking
    # work properly.
    for lang_code, lang_label in sorted(settings.LANGUAGES):
        if lang_code == 'en':
            # Add English as source language
            languages.append(
                ('en', _get_language_display_name('en', 'English')))
            continue
        found_catalogs = [
            gettext_module.find(domain, locale_path,
                                [translation.to_locale(lang_code)])
            for locale_path, domain in itertools.product(
                settings.LOCALE_PATHS, ['django', 'djangojs'])
        ]
        if not all(found_catalogs):
            continue
        # NOTE(amotoki):
        # Check if found catalogs are already processed or not.
        # settings.LANGUAGES can contains languages with a same prefix
        # like es, es-ar, es-mx. gettext_module.find() searchess Message
        # catalog for es-ar in the order of 'es_AR' and then 'es'.
        # If 'es' locale is translated, 'es-ar' is included in the list of
        # found_catalogs even if 'es-ar' is not translated.
        # In this case, the list already includes 'es' and
        # there is no need to include 'es-ar'.
        result = [catalog in processed_catalogs for catalog in found_catalogs]
        if any(result):
            continue
        processed_catalogs |= set(found_catalogs)
        languages.append(
            (lang_code, _get_language_display_name(lang_code, lang_label)))
    return sorted(languages)
Exemple #49
0
    def get_gettext(self, channel=None):
        """
            return a gettext function for the configured language

            @param channel: ignored, its just for compatibilty
                            with ircClient plugins
        """
        lang = self.config.get("language", None, "main", self.network)
        if not lang in self.translations and lang:
            if gettext.find("otfbot", "locale", languages=[lang]):
                self.translations[lang]=gettext.translation("otfbot", "locale", \
                    languages=[lang])
            else:  #no language file found for requested language
                lang = None
        if lang:

            def _(input):
                return self.translations[lang].gettext(input)
        else:

            def _(input):
                return input

        return _
Exemple #50
0
def check_database(update: Update, context: CallbackContext):
    user_data = context.user_data

    try:
        user_data['url']

    except KeyError:
        user_data['url'] = data(update.effective_user.id)

        global lang_code
        lc = update.effective_user.language_code

        user_data['lang'] = (lc if lc and gettext.find(domain, "locale", [lc])
                             else 'en')

    if lang_code != user_data['lang']:
        lang_code = user_data['lang']

        lang = gettext.translation(domain, "locale", [lang_code])
        lang.install(['ngettext'])

    logging.info(
        update_object_type(update).__class__.__name__ + " recieved from " +
        name_and_id(update.effective_user))
Exemple #51
0
def _findLocaleDir(domain):
    import gettext, sys

    # try default location first
    f = gettext.find(domain)
    if f:
        return None

    # next try cwd
    f = gettext.find(domain, 'locale')
    if f:
        return 'locale'

    # next try python prefix
    pydir = os.path.join(sys.prefix, 'share', 'locale')
    f = gettext.find(domain, pydir)
    if f:
        return pydir

    # next try shtoom installation prefix
    import shtoom
    # -5 is prefix , lib, pythonN.N, site-packages, shtoom, __init__.pyc
    prefix = os.path.sep.join(shtoom.__file__.split(os.path.sep)[:-5])
    prefixdir = os.path.join(prefix, 'share', 'locale')
    f = gettext.find(domain, pydir)
    if f:
        return prefixdir

    # Next try alongside 'shtoom' (running from srcdir?)
    srcdir = os.path.join(os.path.split(shtoom.__file__)[0], 'locale')
    f = gettext.find(domain, srcdir)
    if f:
        return srcdir

    # Try python installation prefix
    pydir = os.path.join(sys.prefix, 'share', 'locale')
    f = gettext.find(domain, pydir)
    if f:
        return pydir

    # just wing it
    return None
Exemple #52
0
LOCALE_DIR = join(WHERE_AM_I, '..', 'mo')  # Currently we run from the app dir.
# TODO: Fix this path if we install gnome_usbguard system wide

kwargs = {"localedir": LOCALE_DIR}
if sys.version_info[0] > 3:
    # In Python 2, ensure that the _() that gets installed into built-ins
    # always returns unicodes.  This matches the default behavior under
    # Python 3, although that keyword argument is not present in the
    # Python 3 API.
    kwargs['unicode'] = True
gettext.install(APP, **kwargs)
locale.setlocale(locale.LC_ALL, '')
locale.bindtextdomain(APP, LOCALE_DIR)

# For testing the proper path
print(gettext.find(APP, LOCALE_DIR))
print('Applet using locale directory: {}'.format(LOCALE_DIR))

# Gdk.threads_init()
APPINDICATOR_ID = 'org.gnome.usbguard.appindicator'


class USBGuardAppIndicator(object):
    """App indicator to handle usb events"""

    CURRDIR = os.path.dirname(os.path.abspath(__file__))
    USBGUARD_ICON_PATH = os.path.join(CURRDIR, 'usbguard-icon.svg')

    usbguard_app = None
    notifications = {}
    screensaver_active = False
Exemple #53
0
import config

##
## I18N
##
import locale
import gettext
domain = config.GETTEXT_PACKAGE()
gettext.bindtextdomain(domain, config.GNOMELOCALEDIR())
gettext.textdomain(domain)
_ = gettext.gettext

# Fallback to english if locale setting is unknown
# or translation for this locale is not available
if gettext.find(domain) == None:
    language = "C"
else:
    language = ""
try:
    locale.setlocale(locale.LC_ALL, language)
except:
    warnings.warn_explicit(
        "Locale not supported by Python. Using the fallback 'C' locale.",
        Warning, "lang.py",
        sys.exc_info()[2].tb_frame.f_back.f_lineno)

encoding = locale.getpreferredencoding(False)
language = locale.getlocale()[0]
if language == None:
    language = "C"
Exemple #54
0

# select base string
if _py3k:
    basestring = str

# map between Gedit's translation and PyGtkSpellcheck's
_GEDIT_MAP = {'Languages' : 'Languages',
              'Ignore All' : 'Ignore _All',
              'Suggestions' : 'Suggestions',
              '(no suggestions)' : '(no suggested words)',
              'Add "{}" to Dictionary' : 'Add w_ord',
              'Unknown' : 'Unknown'}

# translation
if gettext.find('gedit'):
    _gedit = gettext.translation('gedit', fallback=True).gettext
    _ = lambda message: _gedit(_GEDIT_MAP[message]).replace('_', '')
else:
    locale_name = 'py{}gtkspellcheck'.format(sys.version_info.major)
    _ = gettext.translation(locale_name, fallback=True).gettext

def code_to_name(code, separator='_'):
    # Escape underscores for GTK menuitems.
    return code.replace(separator, separator * 2)

class SpellChecker(object):
    """
    Main spellchecking class, everything important happens here.

    :param view: GtkTextView the SpellChecker should be attached to.
Exemple #55
0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
GuizeroApp.py
MIT License (c) Faure Systems <dev at faure dot systems>
GuizeroApp extends MqttApp.
"""

from constants import *

import gettext
import os, platform, signal, yaml

try:
    gettext.find("GuizeroApp")
    traduction = gettext.translation('GuizeroApp',
                                     localedir='locale',
                                     languages=['fr'])
    traduction.install()
except:
    _ = gettext.gettext  # cool, this hides PyLint warning Undefined name '_'

from MqttApp import MqttApp
from guizero import App

import sys


class GuizeroApp(MqttApp):

    # __________________________________________________________________
Exemple #56
0
    def _init(cls):
        def callback(widget, allocation):
            cls.widgets["enterGameNotationFrame"].set_size_request(
                223, allocation.height - 4)

        cls.widgets["enterGameNotationSidePanel"].connect_after(
            "size-allocate", callback)

        flags = []
        if isInstalled():
            path = gettext.find("pychess")
        else:
            path = gettext.find("pychess", localedir=addDataPrefix("lang"))
        if path:
            default_locale = locale.getdefaultlocale()
            if default_locale[0] is not None:
                loc = locale.getdefaultlocale()[0][-2:].lower()
                flags.append(addDataPrefix("flags/%s.png" % loc))

        flags.append(addDataPrefix("flags/us.png"))

        cls.ib = ImageButton(flags)
        cls.widgets["imageButtonDock"].add(cls.ib)
        cls.ib.show()

        cls.sourcebuffer = GtkSource.Buffer()
        sourceview = GtkSource.View.new_with_buffer(cls.sourcebuffer)
        sourceview.set_tooltip_text(
            _("Type or paste PGN game or FEN positions here"))
        cls.widgets["scrolledwindow6"].add(sourceview)
        sourceview.show()

        # Pgn format does not allow tabulator
        sourceview.set_insert_spaces_instead_of_tabs(True)
        sourceview.set_wrap_mode(Gtk.WrapMode.WORD)

        man = GtkSource.LanguageManager()
        # Init new version
        if hasattr(man.props, 'search_path'):
            try:
                path = os.path.join(getDataPrefix(),
                                    "gtksourceview-3.0/language-specs")
                man.props.search_path = man.props.search_path + [path]
                if 'pgn' in man.get_language_ids():
                    lang = man.get_language('pgn')
                    cls.sourcebuffer.set_language(lang)
                else:
                    log.warning("Unable to load pgn syntax-highlighting.")
                cls.sourcebuffer.set_highlight_syntax(True)
            except NotImplementedError:
                # Python 2.7.3 in Ubuntu 12.04
                log.warning("Unable to load pgn syntax-highlighting.")
        # Init old version
        else:
            os.environ["XDG_DATA_DIRS"] = getDataPrefix() + ":/usr/share/"
            man = GtkSource.LanguageManager()
            for lang in man.get_available_languages():
                if lang.get_name() == "PGN":
                    cls.sourcebuffer.set_language(lang)
                    break
            else:
                log.warning("Unable to load pgn syntax-highlighting.")
            cls.sourcebuffer.set_highlight(True)
Exemple #57
0
"""Base window of application."""
import os
import gettext
import locale
import platform
import tkinter as tk

from tkinter import font

from FinanceApp.month_window import MonthWindow
from FinanceApp.statistic_window import StatisticsWindow
from FinanceApp.utils import config_widget

if platform.system() != 'Windows':
    locale.setlocale(locale.LC_ALL, locale.getdefaultlocale())
localedir = gettext.find('Months')
localedir = localedir if localedir is not None else os.path.dirname(__file__)
gettext.install('Months', localedir, names=('ngettext', ))


class Application(tk.Frame):
    """
    Main window class.

    :param master: master window
    :param title: title of the application
    """
    def __init__(self, master=None, title=_('Finance management app')):
        """Create main window of application with widgets."""
        if not master:
            master = tk.Tk()
Exemple #58
0
import pygtk
pygtk.require("2.0")
import gtk
import gedit
import time
import os
import sys
import getopt
import ConfigParser
import gettext

APP_NAME = "plugin"
LOC_PATH = os.path.join(
    os.path.expanduser("~/.gnome2/gedit/plugins/reopen-tabs/lang"))

gettext.find(APP_NAME, LOC_PATH)
gettext.install(APP_NAME, LOC_PATH, True)

RELOADER_STATE_READY = "ready"
RELOADER_STATE_INIT = "init"
RELOADER_STATE_RELOADING = "reloading"
RELOADER_STATE_DONE = "done"
RELOADER_STATE_CLOSING = "closing"


def log(msg):
    print '\033[32m' + msg + '\033[0m'


class ReopenTabsPlugin(gedit.Plugin):
    def __init__(self):
Exemple #59
0
def generate_quest(quest):
    gettext.find('quest', 'locales', all=True)
    lang = gettext.translation('quest', localedir='locale', fallback=True)
    lang.install()

    quest_reward_type = questreward(quest['quest_reward_type'])
    quest_type = questtype(quest['quest_type'])
    if '{0}' in quest_type:
        quest_type = quest_type.replace('{0}', str(quest['quest_target']))

    item_id = 0
    item_amount = 1
    pokemon_id = '000'
    pokemon_name = ''
    item_type = ''
    pokemon_form = '00'
    pokemon_costume = '00'
    pokemon_asset_bundle = '00'

    if quest_reward_type == _('Item'):
        item_amount = quest['quest_item_amount']
        item_type = rewarditem(quest['quest_item_id'])
        item_id = quest['quest_item_id']
    elif quest_reward_type == _('Stardust'):
        item_amount = quest['quest_stardust']
        item_type = _('Stardust')
    elif quest_reward_type == _('Pokemon'):
        item_type = 'Pokemon'
        pokemon_name = i8ln(pokemonname(str(quest['quest_pokemon_id'])))
        pokemon_id = quest['quest_pokemon_id']
        pokemon_form = quest['quest_pokemon_form_id']
        pokemon_costume = quest['quest_pokemon_costume_id']
        if pokemon_form != '00':
            pokemon_asset_bundle = form_mapper(int(pokemon_id), pokemon_form)
    elif quest_reward_type == _('Energy'):
        item_type = _('Mega Energy')
        if quest['quest_pokemon_id'] and int(quest['quest_pokemon_id']) > 0:
            pokemon_name = i8ln(pokemonname(str(quest['quest_pokemon_id'])))
            pokemon_id = quest['quest_pokemon_id']
        else:
            pokemon_name = ''
        item_amount = quest['quest_item_amount']

    if not quest['task']:
        quest_task = questtask(quest['quest_type'], quest['quest_condition'],
                               quest['quest_target'], quest['quest_template'])
    else:
        quest_task = quest['task']

    quest_raw = ({
        'pokestop_id': quest['pokestop_id'],
        'name': quest['name'],
        'url': quest['image'],
        'latitude': quest['latitude'],
        'longitude': quest['longitude'],
        'timestamp': quest['quest_timestamp'],
        'item_id': item_id,
        'item_amount': item_amount,
        'item_type': item_type,
        'pokemon_id': pokemon_id,
        'pokemon_name': pokemon_name,
        'pokemon_form': pokemon_form,
        'pokemon_asset_bundle_id': pokemon_asset_bundle,
        'pokemon_costume': pokemon_costume,
        'quest_type': quest_type,
        'quest_type_raw': quest['quest_type'],
        'quest_reward_type': quest_reward_type,
        'quest_reward_type_raw': quest['quest_reward_type'],
        'quest_task': quest_task,
        'quest_target': quest['quest_target'],
        'quest_condition': quest['quest_condition'],
        'quest_template': quest['quest_template'],
    })
    return quest_raw
Exemple #60
0
def questtask(typeid, condition, target, quest_template):
    gettext.find('quest', 'locales', all=True)
    lang = gettext.translation('quest', localedir='locale', fallback=True)
    lang.install()

    pokemonTypes = open_json_file('pokemonTypes')
    items = open_json_file('items')
    throwTypes = {
        "10": _("Nice"),
        "11": _("Great"),
        "12": _("Excellent"),
        "13": _("Curveball")
    }
    arr = {}
    arr['0'] = target
    text = questtype(typeid)
    # TODO use the dict instead of regex parsing in all logic
    condition_dict = {}
    if condition is not None and condition != '':
        condition_dict = json.loads(condition)

    if typeid == 4:
        arr['wb'] = ""
        arr['type'] = ""
        arr['poke'] = ""
        arr['different'] = ""
        arr['item'] = ""

        text = _("Catch {0}{different} {type}Pokemon{wb}")
        match_object = re.search(r'"pokemon_type": \[([0-9, ]+)\]', condition)
        if match_object is not None:
            pt = match_object.group(1).split(', ')
            last = len(pt)
            cur = 1
            if last == 1:
                arr['type'] = pokemonTypes[pt[0]].title() + _('-type ')
            else:
                for ty in pt:
                    arr['type'] += (_('or ') if last == cur else '') + \
                                   pokemonTypes[ty].title() + (_('-type ')
                                                               if last == cur else '-, ')
                    cur += 1
        if re.search(r'"type": 3', condition) is not None:
            arr['wb'] = _(" with weather boost")
        elif re.search(r'"type": 21', condition) is not None:
            arr['different'] = _(" different species of")
        match_object = re.search(r'"pokemon_ids": \[([0-9, ]+)\]', condition)
        if match_object is not None:
            pt = match_object.group(1).split(', ')
            last = len(pt)
            cur = 1
            if last == 1:
                arr['poke'] = i8ln(pokemonname(pt[0]))
            else:
                for ty in pt:
                    arr['poke'] += (_('or ') if last == cur else '') + \
                                   i8ln(pokemonname(ty)) + ('' if last == cur else ', ')
                    cur += 1
            text = _('Catch {0} {poke}')
    elif typeid == 5:
        text = _("Spin {0} Pokestops or Gyms")
        if re.search(r'"type": 12', condition) is not None:
            text = _("Spin {0} Pokestops you haven't visited before")
    elif typeid == 6:
        text = _("Hatch {0} Eggs")
    elif typeid == 7:
        if re.search(r'"type": 9', condition) is not None:
            text = _("Win {0} Gym Battles")
        elif re.search(r'"type": 10', condition) is not None:
            text = _("Use a supereffective Charged Attack in {0} Gym battles")
        else:
            text = _("Battle in a Gym {0} times")
    elif typeid == 8:
        if re.search(r'"type": 6', condition) is not None:
            text = _("Win {0} Raids")
            if re.search(r'"raid_level": \[3, 4, 5\]', condition) is not None:
                text = _('Win a level 3 or higher raid')
            if re.search(r'"raid_level": \[2, 3, 4, 5\]',
                         condition) is not None:
                text = _('Win a level 2 or higher raid')
            if re.search(r'"raid_level": \[6\]', condition) is not None:
                text = _('Win a Mega raid')
        else:
            text = _("Battle in {0} Raids")
    elif typeid == 10:
        text = _("Transfer {0} Pokemon")
    elif typeid == 11:
        text = _("Favourite {0} Pokemon")
    elif typeid == 13:
        text = _('Use {0} {type}Berries to help catch Pokemon')
        arr['type'] = ""
        match_object = re.search(r'"item": ([0-9]+)', condition)
        if match_object is not None:
            arr['type'] = items[match_object.group(1)]['name'].replace(
                _(' Berry'), '') + " "
    elif typeid == 14:
        text = _('Power up Pokemon {0} times')
    elif typeid == 15 or typeid == 43:
        arr['mega'] = ""
        text = _("{mega}Evolve {0} Pokemon")
        if typeid == 43:
            arr['mega'] = _("Mega ")

        for con in condition_dict:
            if con.get('type', 0) == 11:
                text = _("Use an item to {mega}evolve {0} Pokemon")
                # Try to find the exact evolution item needed
                # [{"type": 11, "with_item": {"item": 1106}}]
                with_item = con.get('with_item', {}).get('item', None)
                if with_item is not None:
                    text = _('Use {item} to {mega}evolve {0} Pokemon')
                    arr['item'] = items[str(with_item)]['name']
            if con.get('type', 0) == 1:
                text = _("{mega}Evolve {0} {type}Pokemon")
                arr['wb'] = ""
                arr['type'] = ""
                arr['poke'] = ""
                match_object = re.search(r'"pokemon_type": \[([0-9, ]+)\]',
                                         condition)
                if match_object is not None:
                    pt = match_object.group(1).split(', ')
                    last = len(pt)
                    cur = 1
                    if last == 1:
                        arr['type'] = pokemonTypes[pt[0]].title() + _('-type ')
                    else:
                        for ty in pt:
                            arr['type'] += (_('or ') if last == cur else
                                            '') + pokemonTypes[ty].title() + (
                                                _('-type ')
                                                if last == cur else '-, ')
                            cur += 1
            if con.get('type', 0) == 2:
                arr['wb'] = ""
                arr['type'] = ""
                arr['poke'] = ""

                match_object = re.search(r'"pokemon_ids": \[([0-9, ]+)\]',
                                         condition)
                if match_object is not None:
                    pt = match_object.group(1).split(', ')
                    last = len(pt)
                    cur = 1
                    if last == 1:
                        arr['poke'] = i8ln(pokemonname(pt[0]))
                    else:
                        for ty in pt:
                            arr['poke'] += (_('or ') if last == cur else
                                            '') + i8ln(pokemonname(ty)) + (
                                                '' if last == cur else ', ')
                            cur += 1
                    text = _('{mega}Evolve {0} {poke}')
    elif typeid == 16:
        arr['inrow'] = ""
        arr['curve'] = ""
        arr['type'] = ""
        if re.search(r'"type": 14', condition) is not None:
            arr['inrow'] = _(" in a row")
        if re.search(r'"type": 15', condition) is not None:
            arr['curve'] = _("Curveball ")
        match_object = re.search(r'"throw_type": ([0-9]{2})', condition)
        if match_object is not None:
            arr['type'] = throwTypes[match_object.group(1)] + " "
        text = _("Make {0} {type}{curve}Throws{inrow}")
    elif typeid == 17:
        text = _('Earn {0} Candies walking with your buddy')
    elif typeid == 22:
        if int(target) == int(1):
            text = _('Make a new friend')
        else:
            text = _('Make {0} new friends')
    elif typeid == 23:
        text = _('Trade {0} Pokemon')
        arr['distance'] = ""
        if re.search(r'"type": 25', condition) is not None:
            arr['distance'] = re.search(r'"distance_km": ([0-9, ]+)',
                                        condition).group(1)
            if int(target) == int(1):
                text = _('Trade Pokemon caught {distance} km apart')
            else:
                text = _('Trade {0} Pokemon caught {distance} km apart')
    elif typeid == 24:
        text = _('Send {0} gifts to friends')
    elif typeid == 27:
        for con in condition_dict:
            if con.get('type', 0) == 22:
                # PVP against team leader.
                text = _('Battle a Team Leader {0} times')
            elif con.get('type') == 23:
                gotta_win = con.get('with_pvp_combat',
                                    {}).get('requires_win') is True

                if gotta_win:
                    text = _('Win a battle against another Trainer {0} times')
                else:
                    text = _('Battle another Trainer {0} times')

                in_go_battle_league = any(x in con.get(
                    'with_pvp_combat', {}).get('combat_league_template_id', [])
                                          for x in [
                                              "COMBAT_LEAGUE_VS_SEEKER_GREAT",
                                              "COMBAT_LEAGUE_VS_SEEKER_ULTRA",
                                              "COMBAT_LEAGUE_VS_SEEKER_MASTER"
                                          ])
                vs_player = any(x in con.get('with_pvp_combat', {}).get(
                    'combat_league_template_id', []) for x in [
                        "COMBAT_LEAGUE_DEFAULT_GREAT",
                        "COMBAT_LEAGUE_DEFAULT_ULTRA",
                        "COMBAT_LEAGUE_DEFAULT_MASTER"
                    ])
                if not vs_player and in_go_battle_league and gotta_win:
                    text = _('Win in the GO Battle League {0} times')
                elif in_go_battle_league and not vs_player:
                    text = _('Battle in the GO Battle League {0} times')
    elif typeid == 28:
        # Take snapshots quest
        if re.search(r'"type": 28', condition) is not None:
            text = _("Take {0} snapshots of your Buddy")
        elif re.search(r'"type": 2', condition) is not None:
            arr['poke'] = ""

            match_object = re.search(r'"pokemon_ids": \[([0-9, ]+)\]',
                                     condition)
            if match_object is not None:
                pt = match_object.group(1).split(', ')
                last = len(pt)
                cur = 1
                if last == 1:
                    arr['poke'] = i8ln(pokemonname(pt[0]))
                else:
                    for ty in pt:
                        arr['poke'] += (_('or ') if last == cur else
                                        '') + i8ln(pokemonname(ty)) + (
                                            '' if last == cur else ', ')
                        cur += 1
                text = _("Take {0} snapshots of {poke}")
        elif re.search(r'"type": 1', condition) is not None:
            text = _("Take {0} snapshots of {type} Pokemon")
            arr['wb'] = ""
            arr['type'] = ""
            arr['poke'] = ""
            match_object = re.search(r'"pokemon_type": \[([0-9, ]+)\]',
                                     condition)
            if match_object is not None:
                pt = match_object.group(1).split(', ')
                last = len(pt)
                cur = 1
                if last == 1:
                    arr['type'] = pokemonTypes[pt[0]].title() + _('-type ')
                else:
                    for ty in pt:
                        arr['type'] += (_('or ') if last == cur else
                                        '') + pokemonTypes[ty].title() + (
                                            _('-type ')
                                            if last == cur else '-, ')
                        cur += 1
    elif typeid == 29:
        # QUEST_BATTLE_TEAM_ROCKET Team Go rucket grunt batles.
        if int(target) == int(1):
            text = _('Battle a Team Rocket Grunt')

        for con in condition_dict:
            if con.get('type', 0) == 27 and con.get('with_invasion_character',
                                                    {}).get('category') == 1:
                text = _('Battle {0} times against the Team GO Rocket Leaders')
                # TODO Handle category for specific team leaders as well (Arlo, Cliff, Sierra)
            if con.get('type', 0) == 18:
                # Condition type 18 means win a battle
                # TODO change WIN to Defeat like in-game
                text = text.replace(_('Battle'), _('Defeat'))

    quest_templates = open_json_file('quest_templates')
    if quest_template is not None and quest_template in quest_templates:
        text = _(quest_templates[quest_template])

    if int(target) == int(1):
        text = text.replace(_(' Eggs'), _('n Egg'))
        text = text.replace(_(' Raids'), _(' Raid'))
        text = text.replace(_(' Battles'), _(' Battle'))
        text = text.replace(_(' candies'), _(' candy'))
        text = text.replace(_(' gifts'), _(' gift'))
        text = text.replace(_(' Pokestops'), _(' Pokestop'))
        text = text.replace(_(' {0} snapshots'), _(' a snapshot'))
        text = text.replace(_('Make {0} {type}{curve}Throws'),
                            _('Make a {type}{curve}Throw'))
        text = text.replace(_(' {0} times'), '')
        text = text.replace(_('{0} hearts'), _('a heart'))
        arr['0'] = _("a")

    for key, val in arr.items():
        text = text.replace('{' + key + '}', str(val))

    text = text.replace('  ', ' ').strip()
    return text