pyramid-localize 0.1.0__py2.py3-none-any.whl

pyramid_localize/__init__.py

@@ -0,0 +1,62 @@
+# Copyright (c) 2013-2014 by pyramid_localize authors and contributors <see AUTHORS file>
+#
+# This module is part of pyramid_localize and is released under
+# the MIT License (MIT): http://opensource.org/licenses/MIT
+"""pyramid_localize configuration module."""
+
+try:  # pragma: no cover
+    import babel
+except ImportError:  # pragma: no cover
+    babel = False
+
+from tzf.pyramid_yml import config_defaults
+
+from pyramid_localize.request import (
+    locale, database_locales, locales, locale_id
+)
+
+__version__ = '0.1.0'
+
+
+def includeme(configurator):
+    """pyramid_localize configuration method."""
+    # let's check if we have any configuration, or not
+    if babel:
+        configurator.scan('pyramid_localize.subscribers.i18n')
+        configuration = configurator.registry.get('config', {}).get('localize')
+        if configuration:
+            configurator.include('pyramid_mako')
+            # once user allowed for localization, lets set up default values!
+            config_defaults(configurator, 'pyramid_localize:config')
+
+            configurator.set_locale_negotiator('pyramid_localize.negotiator.locale_negotiator')
+            translation_dirs = configuration.translation.dirs
+            # if it's not a list, lets make it a list.
+            # This is to allow creating both single, and list-like config entry
+            if not isinstance(translation_dirs, list):
+                translation_dirs = [translation_dirs]
+
+            # let's add destination folder to the list
+            if 'destination' in configuration.translation:
+                translation_dirs.append(configuration.translation.destination)
+
+            configurator.add_translation_dirs(*translation_dirs)
+            # let scan all subscribers
+            configurator.scan('pyramid_localize.views')
+
+            configurator.add_route(name='localize:index', pattern='catalogue')
+            configurator.add_route(name='localize:update', pattern='catalogue/update')
+            configurator.add_route(name='localize:compile', pattern='catalogue/compile')
+            configurator.add_route(name='localize:reload', pattern='catalogue/reload')
+
+            # getting requests methods
+            configurator.add_request_method(locale, name='locale', reify=True)
+            configurator.add_request_method(database_locales, name='_database_locales', reify=True)
+            configurator.add_request_method(locales, name='locales')
+            configurator.add_request_method(locale_id, name='locale_id', reify=True)
+
+            # if configured
+            return
+
+    # including fake subscribers
+    configurator.scan('pyramid_localize.subscribers.fake')

pyramid_localize/config/config.yml

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+
+# Copyright (c) 2013-2014 by pyramid_localize authors and contributors <see AUTHORS file>
+#
+# This module is part of pyramid_localize and is released under
+# the MIT License (MIT): http://opensource.org/licenses/MIT
+localize:
+    pybabel: pybabel
+    locales:    # available and default locale for your app
+        available: [en, de, pl]
+        default: en
+    translation:
+        dirs: []

pyramid_localize/models.py

@@ -0,0 +1,37 @@
+# Copyright (c) 2013-2014 by pyramid_localize authors and contributors <see AUTHORS file>
+#
+# This module is part of pyramid_localize and is released under
+# the MIT License (MIT): http://opensource.org/licenses/MIT
+"""Language model."""
+
+
+from sqlalchemy import Column
+from sqlalchemy import Sequence
+from sqlalchemy import Integer
+from sqlalchemy import String
+from sqlalchemy import Unicode
+from sqlalchemy import DateTime
+from sqlalchemy import func
+
+from pyramid_basemodel import Base
+
+
+class Language(Base):
+
+    """Language table model definition."""
+
+    __tablename__ = 'languages'
+
+    id = Column(Integer, Sequence(__tablename__ + '_sq'), primary_key=True)
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now(), nullable=False)
+    name = Column(Unicode(45), nullable=False)
+    native_name = Column(Unicode(45), nullable=False)
+    language_code = Column(String(2), unique=True, nullable=False)  # ISO 639-1 (Alpha2)
+
+    def __unicode__(self):  # pragma: no cover
+        """Language to unicode conversion."""
+        return self.name
+
+    def __str__(self):  # pragma: no cover
+        """Language to string conversion."""
+        return self.name.encode('utf8')

pyramid_localize/negotiator.py

@@ -0,0 +1,41 @@
+# Copyright (c) 2013-2014 by pyramid_localize authors and contributors <see AUTHORS file>
+#
+# This module is part of pyramid_localize and is released under
+# the MIT License (MIT): http://opensource.org/licenses/MIT
+"""Locale negotiator."""
+
+
+def locale_negotiator(request):
+    """
+    Locale negotiator.
+
+    It sets best suited locale variable for given user:
+
+    1. Check for presence and value of **request._LOCALE_** value
+    2. Then tries the address url, if the first part has locale indicator.
+    3. It checks cookies, for value set here
+    4. Tries to best match accepted language for browser user is visiting
+        website with
+    5. Defaults to **localize.locales.default** configuration setting value
+
+    :param pyramid.request.Request request: a request object
+    :returns: locale name
+    :rtype: str
+    """
+    available_languages = request.registry['config'].localize.locales.available
+    locale = request.registry['config'].localize.locales.default
+    # We do not have a matchdict present at the moment, lets get our own split
+    # (request.path is always a /, so we'll get two elements)
+    route_elements = request.path.split('/')
+    if hasattr(request, '_LOCALE_') and request._LOCALE_ in available_languages:
+        locale = request._LOCALE_
+    # we check if route_element[1] is a locale indicator for path
+    elif len(route_elements[1]) == 2 and route_elements[1] in available_languages:
+        locale = route_elements[1]
+    elif request.cookies and '_LOCALE_' in request.cookies and\
+            request.cookies['_LOCALE_'] in available_languages:
+        locale = request.cookies['_LOCALE_']
+    elif request.accept_language:
+        locale = request.accept_language.best_match(available_languages)
+
+    return locale

pyramid_localize/request.py

@@ -0,0 +1,124 @@
+# Copyright (c) 2013-2014 by pyramid_localize authors and contributors <see AUTHORS file>
+#
+# This module is part of pyramid_localize and is released under
+# the MIT License (MIT): http://opensource.org/licenses/MIT
+"""Request related code."""
+
+import warnings
+
+from pyramid.compat import text_type
+import pyramid_basemodel
+
+from pyramid_localize.models import Language
+
+
+class LocalizeRequestMixin(object):
+
+    """Mixin adding overwriting Request methods."""
+
+    def default_locale(self, **kw):
+        """
+        Set up default locale for path kwargs.
+
+        Can be used in custom route_url overwrites.
+
+        :param kwargs kw: list of route parts
+
+        :returns: kw
+        """
+        if '__LOCALE__' not in kw \
+                or kw['__LOCALE__'] not in self.registry['config'].localize.locales.available:
+            kw['__LOCALE__'] = self.locale_name
+
+        return kw
+
+    def route_url(self, route_name, *elements, **kw):
+        """
+        Overwrite original route_url to handle default locale within route.
+
+        .. note:: see :meth:`pyramid.request.Request.route_url`
+        """
+        return super(LocalizeRequestMixin, self).route_url(
+            route_name, *elements, **self.default_locale(**kw)
+        )
+
+
+def locale(request):
+    """
+    Return locale name.
+
+    .. warning::
+
+        Since pyramid 1.5 this function is obsolete and will be deprecated
+        in future versions of pyramid_localize
+
+    When called for the first time, it ask environment for language code,
+    which is later available as a pure property
+    overriding this method
+
+    :returns: language code needed for translations
+    :rtype: string
+    """
+    warnings.warn(
+        'request.locale is deprecated as of pyramid_localize 0.1. '
+        'Please use request.locale_name delivered by Pyramid 1.5.',
+        DeprecationWarning,
+        2
+    )
+    return request.locale_name
+
+
+def locale_id(request):
+    """
+    Return database id of a current locale name.
+
+    :returns: database id of a language code needed for translations
+    :rtype: int
+    """
+    if request.locale_name not in request._database_locales:
+        _create_locale(request.locale_name, request)
+
+    return request._database_locales[request.locale_name].id
+
+
+def database_locales(request):
+    """
+    Return list of all database locales available.
+
+    :returns: dictionary of Language objects language_code: Language
+    :rtype: dict
+    """
+    locales = {}
+    for language in pyramid_basemodel.Session.query(Language).all():
+        locales[language.language_code] = language
+
+    return locales
+
+
+def locales(request, config=False):
+    """
+    Return a list of locales.
+
+    :param bool config: Whether to restrict list with config
+
+    :returns: dictionary of Language objects language_code: Language
+    :rtype: dict
+    """
+    if config:
+        locales = {}
+        for locale in request.registry['config'].localize.locales.available:
+            if locale not in request._database_locales:
+                _create_locale(locale, request)
+            locales[locale] = request._database_locales[locale]
+
+        return locales
+
+    return request._database_locales
+
+
+def _create_locale(locale, request):
+    new_locale = Language(name=text_type(locale),
+                          native_name=text_type(locale),
+                          language_code=text_type(locale))
+    pyramid_basemodel.Session.add(new_locale)
+    request._database_locales = database_locales(request)

pyramid_localize/resources/locale/pyramid_localize.pot

@@ -0,0 +1,58 @@
+# Translations template for pyramid_localize.
+# Copyright (C) 2013 ORGANIZATION
+# This file is distributed under the same license as the pyramid_localize
+# project.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2013.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: pyramid_localize 0.0.1\n"
+"Report-Msgid-Bugs-To: EMAIL@ADDRESS\n"
+"POT-Creation-Date: 2013-06-06 22:20+0200\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <LL@li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 0.9.6\n"
+
+#: pyramid_localize/resources/templates/_list.mako:5
+msgid "Language"
+msgstr ""
+
+#: pyramid_localize/resources/templates/_list.mako:6
+msgid "Translation domain"
+msgstr ""
+
+#: pyramid_localize/resources/templates/_list.mako:7
+#: pyramid_localize/resources/templates/_list.mako:8
+#: pyramid_localize/resources/templates/_list.mako:9
+msgid "${type} modification time"
+msgstr ""
+
+#: pyramid_localize/resources/templates/index.mako:4
+msgid "Translations"
+msgstr ""
+
+#: pyramid_localize/resources/templates/index.mako:6
+msgid "Update catalog"
+msgstr ""
+
+#: pyramid_localize/resources/templates/index.mako:7
+msgid "Compile catalog"
+msgstr ""
+
+#: pyramid_localize/resources/templates/index.mako:8
+msgid "Reload catalog"
+msgstr ""
+
+#: pyramid_localize/resources/templates/layout.mako:3
+msgid "Welcome, to pyramid_localize!"
+msgstr ""
+
+#: pyramid_localize/views/catalog.py:166
+msgid "Localizators has been reloaded"
+msgstr ""
+

pyramid_localize/resources/templates/_list.mako

@@ -0,0 +1,33 @@
+<%doc>
+ Copyright (c) 2013-2014 by pyramid_localize authors and contributors <see AUTHORS file>
+
+ This module is part of pyramid_localize and is released under
+ the MIT License (MIT): http://opensource.org/licenses/MIT
+</%doc>
+<table class="table table-hover">
+    <thead>
+        <tr>
+            <th>${_('Language', domain='pyramid_localize')}</th>
+            <th>${_('Translation domain', domain='pyramid_localize')}</th>
+            <th>${_('${type} modification time', domain='pyramid_localize', mapping={'type': 'pot'})}</th>
+            <th>${_('${type} modification time', domain='pyramid_localize', mapping={'type': 'po'})}</th>
+            <th>${_('${type} modification time', domain='pyramid_localize', mapping={'type': 'mo'})}</th>
+        </tr>
+    </thead>
+    <tbody>
+        % for language in translations:
+            <tr>
+                <td rowspan="${len(translations[language]) if len(translations[language]) > 1 else 1}">${language}</td>
+                % for domain in translations[language]:
+                        <td>${domain}</td>
+                        <td>${translations[language][domain]['pot']}</td>
+                        <td>${translations[language][domain]['po']}</td>
+                        <td>${translations[language][domain]['mo']}</td>
+                    % if len(translations[language]) > 1:
+                        </tr><tr>
+                    % endif
+                % endfor
+            </tr>
+        % endfor
+    </tbody>
+</table>

pyramid_localize/resources/templates/index.mako

@@ -0,0 +1,19 @@
+<%doc>
+ Copyright (c) 2013-2014 by pyramid_localize authors and contributors <see AUTHORS file>
+
+ This module is part of pyramid_localize and is released under
+ the MIT License (MIT): http://opensource.org/licenses/MIT
+</%doc>
+<%inherit file="pyramid_localize:resources/templates/layout.mako" />
+<div class="row">
+    <div class="span9">
+        <h1>${_('Translations', domain='pyramid_localize')}</h1>
+        <p>
+            <a href="${request.route_path('localize:update')}" class="btn">${_('Update catalog', domain='pyramid_localize')}</a>
+            <a href="${request.route_path('localize:compile')}" class="btn">${_('Compile catalog', domain='pyramid_localize')}</a>
+            <a href="${request.route_path('localize:reload')}" class="btn">${_('Reload catalog', domain='pyramid_localize')}</a>
+        </p>
+        <%include file="_list.mako" />
+
+    </div>
+</div>

pyramid_localize/resources/templates/layout.mako

@@ -0,0 +1,12 @@
+<%doc>
+ Copyright (c) 2013-2014 by pyramid_localize authors and contributors <see AUTHORS file>
+
+ This module is part of pyramid_localize and is released under
+ the MIT License (MIT): http://opensource.org/licenses/MIT
+</%doc>
+<html>
+    <body>
+        <h1>${_('Welcome, to pyramid_localize!', domain='pyramid_localize')}</h1>
+        ${next.body()}
+    </body>
+</html>

pyramid_localize/routing/__init__.py

@@ -0,0 +1,5 @@
+# Copyright (c) 2013-2014 by pyramid_localize authors and contributors <see AUTHORS file>
+#
+# This module is part of pyramid_localize and is released under
+# the MIT License (MIT): http://opensource.org/licenses/MIT
+"""Routing related modules."""

pyramid_localize/routing/predicates.py

@@ -0,0 +1,18 @@
+# Copyright (c) 2013-2014 by pyramid_localize authors and contributors <see AUTHORS file>
+#
+# This module is part of pyramid_localize and is released under
+# the MIT License (MIT): http://opensource.org/licenses/MIT
+"""Localize route predicate."""
+
+
+def language(field):
+    """Create language predicate for given url match field."""
+    def predicate(info, request):
+        """Check whether language is one of the defaults."""
+        if field in info['match'] and\
+                info['match'][field] in request.registry['config'].localize.locales.available:
+            return True
+        return False
+    return predicate
+
+language.__text__ = 'language predicate, to determine allowed languages in route'

pyramid_localize/subscribers/__init__.py

@@ -0,0 +1,5 @@
+# Copyright (c) 2013-2014 by pyramid_localize authors and contributors <see AUTHORS file>
+#
+# This module is part of pyramid_localize and is released under
+# the MIT License (MIT): http://opensource.org/licenses/MIT
+"""Event subscribers, fake and real."""

pyramid_localize/subscribers/fake.py

@@ -0,0 +1,27 @@
+# Copyright (c) 2013-2014 by pyramid_localize authors and contributors <see AUTHORS file>
+#
+# This module is part of pyramid_localize and is released under
+# the MIT License (MIT): http://opensource.org/licenses/MIT
+"""Subscribers adding mocked translation methods to render context, and request."""
+
+from pyramid.events import subscriber
+from pyramid.events import BeforeRender
+from pyramid.events import NewRequest
+
+from pyramid_localize.tools import dummy_autotranslate
+
+
+@subscriber(BeforeRender)
+def global_renderer(event):
+    """BeforeRender subscriber, adds fake localizer, and translation methods to context."""
+    request = event['request']
+    try:
+        event['_'] = request._
+    except AttributeError:
+        event['_'] = dummy_autotranslate
+
+
+@subscriber(NewRequest)
+def add_localizer(event):
+    """NewRequest subscriber, adds fake localizer and translation methods to request."""
+    event.request._ = dummy_autotranslate

pyramid_localize/subscribers/i18n.py

@@ -0,0 +1,27 @@
+# Copyright (c) 2013-2014 by pyramid_localize authors and contributors <see AUTHORS file>
+#
+# This module is part of pyramid_localize and is released under
+# the MIT License (MIT): http://opensource.org/licenses/MIT
+"""i18n subscribers."""
+
+from pyramid.events import subscriber
+from pyramid.events import BeforeRender
+from pyramid.events import NewRequest
+
+from pyramid_localize.tools import set_localizer
+
+
+@subscriber(BeforeRender)
+def global_renderer(event):
+    """BeforeRender subscriber, adds localizer, and translation methods to context."""
+    request = event['request']
+    set_localizer(request)
+
+    event['_'] = request._
+    event['localizer'] = request.localizer
+
+
+@subscriber(NewRequest)
+def add_localizer(event):
+    """NewRequest subscriber, adds localizer and translation methods to request."""
+    set_localizer(event.request)

pyramid_localize/tools.py

@@ -0,0 +1,100 @@
+# Copyright (c) 2013-2014 by pyramid_localize authors and contributors <see AUTHORS file>
+#
+# This module is part of pyramid_localize and is released under
+# the MIT License (MIT): http://opensource.org/licenses/MIT
+"""methods in this module are tools, thank to which pyramid_localize works most of its magic."""
+
+import sys
+import os
+import logging
+
+from translationstring import _interp_regex
+from pyramid.i18n import make_localizer
+from pyramid.i18n import TranslationString
+from pyramid.asset import resolve_asset_spec
+from pyramid.path import package_path
+from pyramid.interfaces import ILocalizer
+from pyramid.interfaces import ITranslationDirectories
+from pyramid.compat import text_type
+
+logger = logging.getLogger(__name__)
+
+
+def set_localizer(request, reset=False):
+    """
+    Set localizer and auto_translate methods for request.
+
+    :param pyramid.request.Request request: request object
+    :param bool reset: flag that directs resetting localizer within app
+    """
+    if reset:
+
+        for locale in request.registry['config'].localize.locales.available:
+            logger.debug('Resetting {0} localizator'.format(locale))
+            tdirs = request.registry.queryUtility(ITranslationDirectories,
+                                                  default=[])
+            localizer = make_localizer(locale, tdirs)
+            request.registry.registerUtility(localizer, ILocalizer,
+                                             name=locale)
+
+    def auto_translate(*args, **kwargs):
+        # lets pass default domain, so we don't have to determine it with
+        # each _() function in apps.
+        if len(args) <= 1 and 'domain' not in kwargs:
+            kwargs['domain'] = request.registry['config'].localize.domain
+
+        # unlike in examples we use TranslationString, to make sure we always
+        # use appropriate domain
+        return request.localizer.translate(TranslationString(*args, **kwargs))
+
+    request._ = auto_translate
+
+
+def destination_path(request):
+    """
+    Return absolute path of the translation destination.
+
+    :param pyramid.request.Request request: a request object
+
+    :returns: A combined translation destination path
+    :rtype: str
+    """
+    package_name, filename = resolve_asset_spec(
+        request.registry['config'].localize.translation.destination
+    )
+
+    if package_name is None:  # absolute filename
+        directory = filename
+    else:
+        __import__(package_name)
+        package = sys.modules[package_name]
+        directory = os.path.join(package_path(package), filename)
+    return directory
+
+
+def dummy_autotranslate(msgid, domain=None, default=None, mapping=None):
+    """
+    Method that simulate autotranslate.
+
+    :param str msgid: Message or message id
+    :param str domain: Translation domain
+    :param str default: Default message
+    :param dict mapping: Mapping dictionary for message variables
+
+    :returns: *translated* string
+    :rtype: str
+    """
+    # Try to return defaults first:
+    tstr = None
+    if default:
+        tstr = default
+    else:
+        tstr = msgid
+
+    if mapping and tstr:
+        def replace(match):
+            whole, param1, param2 = match.groups()
+            return text_type(mapping.get(param1 or param2, whole))
+        tstr = _interp_regex.sub(replace, tstr)
+
+    return tstr

pyramid_localize/views/__init__.py

@@ -0,0 +1,5 @@
+# Copyright (c) 2013-2014 by pyramid_localize authors and contributors <see AUTHORS file>
+#
+# This module is part of pyramid_localize and is released under
+# the MIT License (MIT): http://opensource.org/licenses/MIT
+"""View submodules."""