示例#1
0
文件: cli.py 项目: annndrey/npui
import logging
import os
import pkg_resources
import re

from cliff.lister import Lister
from cliff.show import ShowOne
from cliff.command import Command

from pyramid.i18n import TranslationStringFactory
from sqlalchemy.exc import ProgrammingError
from alembic import command as alembic_cmd

from netprofile.common.modules import ModuleError

_ = TranslationStringFactory('netprofile')


class ListModules(Lister):
    """
	List available/installed modules.
	"""

    log = logging.getLogger(__name__)

    def get_parser(self, prog_name):
        parser = super(ListModules, self).get_parser(prog_name)
        parser.add_argument('-F',
                            '--filter',
                            choices=('all', 'installed', 'uninstalled',
                                     'enabled', 'disabled'),
示例#2
0
from plumber import default
from plumber import plumb
from pyramid.i18n import TranslationStringFactory
from pyramid.security import ALL_PERMISSIONS
from pyramid.security import Allow
from pyramid.security import Deny
from pyramid.security import Everyone
from pyramid.security import authenticated_userid
from pyramid.security import remember
from pyramid.threadlocal import get_current_request
from zope.interface import implementer
import logging


logger = logging.getLogger('cone.app')
_ = TranslationStringFactory('cone.app')


DEFAULT_ROLES = [
    ('viewer', _('role_viewer', default='Viewer')),
    ('editor', _('role_editor', default='Editor')),
    ('admin', _('role_admin', default='Admin')),
    ('manager', _('role_manager', default='Manager')),
]


authenticated_permissions = [
    'view',
]
viewer_permissions = [
    'view', 'list',
示例#3
0
文件: __init__.py 项目: annndrey/npui
# Public License along with NetProfile. If not, see
# <http://www.gnu.org/licenses/>.

from __future__ import (unicode_literals, print_function, absolute_import,
                        division)

from netprofile.common.modules import ModuleBase

from sqlalchemy.orm.exc import NoResultFound
from pyramid.i18n import TranslationStringFactory

from ._version import get_versions
__version__ = get_versions()['version']
del get_versions

_ = TranslationStringFactory('netprofile_dialup')


class Module(ModuleBase):
    def __init__(self, mmgr):
        self.mmgr = mmgr
        mmgr.cfg.add_translation_dirs('netprofile_dialup:locale/')
        mmgr.cfg.scan()

    @classmethod
    def get_models(cls):
        from netprofile_dialup import models
        return (models.IPPool, models.NAS, models.NASPool)

    @classmethod
    def get_sql_data(cls, modobj, vpair, sess):
示例#4
0
文件: i18n.py 项目: kailIII/anuket
# -*- coding: utf-8 -*-
""" Define a message factory and a locale negotiator."""
from pyramid.i18n import TranslationStringFactory

MessageFactory = TranslationStringFactory('anuket')


def locale_negotiator(request):
    """ Return a locale name by looking at the ``Accept-Language`` HTTP header.

    :param request: a ``pyramid.request`` object
    :return: the language code
    """
    settings = request.registry.settings
    available_languages = settings['pyramid.available_languages'].split()
    return request.accept_language.best_match(available_languages)
示例#5
0
#
# This file is part of Yith Library Server.
#
# Yith Library Server is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Yith Library Server is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with Yith Library Server.  If not, see <http://www.gnu.org/licenses/>.

from pyramid.i18n import get_localizer, TranslationStringFactory
from pyramid.threadlocal import get_current_request

translation_domain = 'yithlibraryserver'
TranslationString = TranslationStringFactory(translation_domain)


def deform_translator(term):
    return get_localizer(get_current_request()).translate(term)


def locale_negotiator(request):
    available_languages = request.registry.settings['available_languages']
    return request.accept_language.best_match(available_languages)
示例#6
0
from pyramid.i18n import TranslationStringFactory
from pyramid.view import view_config
from pyramid.httpexceptions import HTTPFound

from bson import ObjectId

_ = TranslationStringFactory('todopyramid')


@view_config(route_name='index', renderer='todopyramid:templates/index.jinja2')
def index(request):
    '''Return all TodoList'''
    db = request.db
    todo_lists = list(db.todolist.find())

    return {'todolist': todo_lists}


@view_config(route_name='new', renderer='todopyramid:templates/new.jinja2')
def new(request):

    db = request.db
    todo = {}

    if request.POST:
        form = dict(request.params.items())
        db.todolist.insert(form)
        return HTTPFound('/')

    return {'todo': todo}
示例#7
0
# -*- coding: utf-8 -*-
"""
Created on 2015-10-26
:author: Joseph Rawson ([email protected])
"""

from kotti.resources import File
from pyramid.i18n import TranslationStringFactory

_ = TranslationStringFactory('kotti_dashboard')


def kotti_configure(settings):
    """ Add a line like this to you .ini file::

            kotti.configurators =
                kotti_dashboard.kotti_configure

        to enable the ``kotti_dashboard`` add-on.

    :param settings: Kotti configuration dictionary.
    :type settings: dict
    """

    settings['pyramid.includes'] += ' kotti_dashboard pyramid_mako'


def includeme(config):
    """ Don't add this to your ``pyramid_includes``, but add the
    ``kotti_configure`` above to your ``kotti.configurators`` instead.
示例#8
0
import csv
import codecs
import unicodedata

from collections import Counter
from hashids import Hashids
from pyenketo import Enketo
from babel.dates import format_date
from whoahqa.constants import characteristics
from pyramid.i18n import TranslationStringFactory, get_localizer

translation_string_factory = TranslationStringFactory('who-ahqa')
hashid = Hashids(min_length=4, alphabet='abcdefghijklmnpqrstuvwxyz123456789')
enketo = Enketo()

INITIAL_SCORE_MAP = {
    characteristics.EQUITABLE: 0,
    characteristics.ACCESSIBLE: 0,
    characteristics.ACCEPTABLE: 0,
    characteristics.APPROPRIATE: 0,
    characteristics.EFFECTIVE: 0
}


def tuple_to_dict_list(key_tuple, value_tuples):
    return [dict(zip(key_tuple, c)) for c in value_tuples]


def format_date_for_locale(value, format_def, request):
    localizer = get_localizer(request)
    return format_date(value, format_def, locale=localizer.locale_name)
示例#9
0
import wtforms as wtf
from wtforms import validators
from pyramid.i18n import TranslationStringFactory

from intranet3.models import DBSession, Tracker, Project, Client
from intranet3.models.project import STATUS
from .utils import EntityChoices, UserChoices

_ = TranslationStringFactory('intranet3')


class ProjectForm(wtf.Form):
    """ Project form """
    name = wtf.TextField(_(u"Project name"), validators=[validators.Required()])
    coordinator_id = wtf.SelectField(_(u"Coordinator"), validators=[], choices=UserChoices(empty=True))
    tracker_id = wtf.SelectField(_(u"Tracker"), validators=[validators.Required()], choices=EntityChoices(Tracker, lambda tracker: tracker.name))
    status = wtf.SelectField(_(u"Status"), validators=[validators.Required()], choices=STATUS)
    turn_off_selectors = wtf.BooleanField(_(u"Turn off selectors"), validators=[], default=True)
    project_selector = wtf.TextField(_(u"Project selector"), validators=[])
    component_selector = wtf.TextField(_(u"Component selector"), validators=[])
    version_selector = wtf.TextField(_(u"Version selector"), validators=[])
    ticket_id_selector = wtf.TextField(_(u"Ticket ID selector"), validators=[])
    active = wtf.BooleanField(_(u"Active"), validators=[], default=True)
    google_card = wtf.TextField(_(u"Link to project card in google docs"), validators=[])
    google_wiki = wtf.TextField(_(u"Link to project wiki in google sites"), validators=[])
    mailing_url = wtf.TextField(_(u"Link to mailing group"), validators=[])

    working_agreement = wtf.TextAreaField(_("Working agreement"))
    definition_of_done = wtf.TextAreaField(_("Definition of done"))
    definition_of_ready = wtf.TextAreaField(_("Definition of ready"))
    continuous_integration_url = wtf.StringField(_("Continuous integration link"))
示例#10
0
 def _makeOne(self, *arg, **kw):
     from pyramid.i18n import TranslationStringFactory
     return TranslationStringFactory(*arg, **kw)
示例#11
0
from pyramid_mailer.interfaces import IMailer
from pyramid_mailer.message import Message
from pyramid.traversal import resource_path
from pyramid.request import Request
from pyramid.threadlocal import get_current_request
from pyramid.i18n import TranslationStringFactory

from adhocracy_core.interfaces import IResource
from adhocracy_core.resources.principal import IUser
from adhocracy_core.sheets.principal import IUserBasic
from adhocracy_core.sheets.principal import IUserExtended
from adhocracy_core.utils import get_sheet_field

logger = getLogger(__name__)

_ = TranslationStringFactory('adhocracy')


class Messenger:
    """Send messages to other people."""
    def __init__(self, registry: Registry):
        """Create a new instance.

        :param registry: used to retrieve and configure the mailer
        """
        self.registry = registry
        settings = registry.settings
        self.use_mail_queue = asbool(
            settings.get('adhocracy.use_mail_queue', False))
        logger.debug('Messenger will use mail queue: %s', self.use_mail_queue)
        self.abuse_handler_mail = settings.get('adhocracy.abuse_handler_mail')
示例#12
0
from pyramid.security import remember, forget, authenticated_userid
from pyramid.response import Response
from sqlalchemy.orm import scoped_session, sessionmaker
from sqlalchemy import engine_from_config
import sqlahelper
from owslib.wms import WebMapService
from xml.dom.minidom import parseString
from math import sqrt

from c2cgeoportal.lib import get_setting, caching, get_protected_layers_query
from c2cgeoportal.lib.functionality import get_functionality
from c2cgeoportal.models import DBSession, Layer, LayerGroup, \
    Theme, RestrictionArea, Role, User
from c2cgeoportal.lib.wmstparsing import parse_extent, TimeInformation

_ = TranslationStringFactory('c2cgeoportal')
log = logging.getLogger(__name__)
cache_region = caching.get_region()


class Entry(object):

    WFS_NS = "http://www.opengis.net/wfs"

    def __init__(self, request):
        self.request = request
        if request.user:
            request.response.cache_control.private = True
        else:
            request.response.cache_control.public = True
        request.response.cache_control.max_age = \
示例#13
0
import os
import pkg_resources
import snimpy.mib

from netprofile.common.modules import ModuleBase

from sqlalchemy.orm.exc import NoResultFound
from pyramid.config import aslist
from pyramid.i18n import TranslationStringFactory

from ._version import get_versions
__version__ = get_versions()['version']
del get_versions

_ = TranslationStringFactory('netprofile_devices')

class Module(ModuleBase):
	def __init__(self, mmgr):
		self.mmgr = mmgr
		mmgr.cfg.add_translation_dirs('netprofile_devices:locale/')
		mmgr.cfg.scan()

	@classmethod
	def get_deps(cls):
		return ('entities', 'hosts', 'rates')

	@classmethod
	def get_models(cls):
		from netprofile_devices import models
		return (
示例#14
0
from pyramid.i18n import TranslationStringFactory
_ = TranslationStringFactory('alexandria')

import colander

from ..models import User

@colander.deferred
def login_username_password(node, kw):
    request = kw.get('request')

    if request is None:
        raise KeyError('Require bind: request')

    def username_password(form, value):
        user = User.validate_user_password(request.dbsession, value['email'],
                value['password'])

        if user is None:
            exc = colander.Invalid(form, _("Username or password is incorrect"))
            exc['email'] = ''
            exc['password'] = ''
            raise exc

        value['email'] = user.email

    return username_password

class UserSchema(colander.Schema):
    """The user login form."""
示例#15
0
from pyramid.i18n import TranslationStringFactory
_ = TranslationStringFactory(__package__)

MISSING_PARAMETER = _('Missing parameter')
NOT_LOGGED_IN = _('You must be logged in to do that!')
示例#16
0
文件: util.py 项目: puiterwijk/bodhi
from sqlalchemy import create_engine
from sqlalchemy.orm import scoped_session, sessionmaker
from zope.sqlalchemy import ZopeTransactionExtension
from pyramid.i18n import TranslationStringFactory
from pyramid.settings import asbool

from . import log, buildsys
from .exceptions import RepodataException
from .config import config

try:
    import rpm
except ImportError:
    log.warning("Could not import 'rpm'")

_ = TranslationStringFactory('bodhi')

## Display a given message as a heading
header = lambda x: u"%s\n     %s\n%s\n" % ('=' * 80, x, '=' * 80)

pluralize = lambda val, name: val == 1 and name or "%ss" % name


def get_rpm_header(nvr, tries=0):
    """ Get the rpm header for a given build """

    tries += 1
    headers = [
        'name', 'summary', 'version', 'release', 'url', 'description',
        'changelogtime', 'changelogname', 'changelogtext',
    ]
示例#17
0
文件: util.py 项目: Python3pkg/Kotti
from pyramid.i18n import TranslationStringFactory
from pyramid.interfaces import ITranslationDirectories
from pyramid.location import inside
from pyramid.paster import bootstrap
from pyramid.paster import setup_logging
from pyramid.renderers import render
from pyramid.threadlocal import get_current_registry
from pyramid.threadlocal import get_current_request
from pyramid.url import resource_url
from pyramid.view import render_view_to_response
from repoze.lru import LRUCache
from zope.deprecation import deprecated

from kotti import DBSession

_ = TranslationStringFactory('Kotti')


def get_localizer_for_locale_name(locale_name):
    registry = get_current_registry()
    tdirs = registry.queryUtility(ITranslationDirectories, default=[])
    return make_localizer(locale_name, tdirs)


def translate(*args, **kwargs):
    request = get_current_request()
    if request is None:
        localizer = get_localizer_for_locale_name('en')
    else:
        localizer = get_localizer(request)
    return localizer.translate(*args, **kwargs)
示例#18
0
#
# Copyright (c) 2015-2019 Thierry Florac <tflorac AT ulthar.net>
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
"""PyAMS_viewlet package

PyAMS viewlets management package
"""

__docformat__ = 'restructuredtext'

from pyramid.i18n import TranslationStringFactory

_ = TranslationStringFactory('pyams_viewlet')


def includeme(config):
    """pyams_viewlet features include"""
    from .include import include_package  # pylint: disable=import-outside-toplevel
    include_package(config)
示例#19
0
from testscaffold.grids import (
    ResourceUserPermissionsGrid,
    ResourceGroupPermissionsGrid)
from testscaffold.models.entry import Entry
from testscaffold.services.resource_tree_service import tree_service
from testscaffold.validation.forms import (
    UserResourcePermissionForm,
    GroupResourcePermissionForm,
    EntryCreateForm
)
from testscaffold.views import BaseView
from testscaffold.views.shared.entries import EntriesShared

log = logging.getLogger(__name__)

_ = TranslationStringFactory('testscaffold')


def get_possible_parents(request):
    result = tree_service.from_parent_deeper(
        db_session=request.dbsession)

    choices = [('', request.localizer.translate(_('Root (/)')))]
    for row in result:
        choices.append((row.Resource.resource_id,
                        '{} {}'.format('--' * row.depth,
                                       row.Resource.resource_name)))
    return choices


@view_defaults(route_name='admin_objects', permission='admin_entries')
示例#20
0
#
# Copyright (c) 2015-2019 Thierry Florac <tflorac AT ulthar.net>
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
"""PyAMS_file package

PyAMS files management package
"""

__docformat__ = 'restructuredtext'

from pyramid.i18n import TranslationStringFactory

_ = TranslationStringFactory('pyams_file')


def includeme(config):
    """pyams_file features include"""
    from .include import include_package  # pylint: disable=import-outside-toplevel
    include_package(config)
示例#21
0
from cone.ugm.utils import general_settings
from plumber import Behavior
from plumber import default
from plumber import plumb
from pyramid.i18n import TranslationStringFactory

_ = TranslationStringFactory('cone.ugm')


class AutoIncrementForm(Behavior):
    """Plumbing behavior for setting user id by auto increment logic.

    For user add form.
    """
    @default
    @property
    def autoincrement_support(self):
        settings = general_settings(self.model)
        return settings.attrs.user_id_autoincrement == 'True'

    @default
    @property
    def next_principal_id(self):
        settings = general_settings(self.model)
        prefix = settings.attrs.user_id_autoincrement_prefix
        default = int(settings.attrs.user_id_autoincrement_start)
        search = u'%s*' % prefix
        backend = self.model.parent.backend
        backend.invalidate()
        result = backend.search(attrlist=['id'], criteria={'id': search})
        if result and isinstance(result[0][1]['id'], list):
示例#22
0
from babel.core import Locale
from pyramid.i18n import TranslationStringFactory, default_locale_negotiator
from pyramid.threadlocal import get_current_request

KNOWN_LOCALES = {
    "en": "English",
    "es": "Spanish",
    "fr": "French",
    "ja": "Japanese",
    "pt_BR": "Portuguese (Brazil)",
    "uk": "Ukrainian",
}

LOCALE_ATTR = "_LOCALE_"

_translation_factory = TranslationStringFactory("messages")


class LazyString:
    def __init__(self, fn, *args, **kwargs):
        self.fn = fn
        self.args = args
        self.mapping = kwargs.get("mapping", {})
        self.kwargs = kwargs

    def __json__(self, request):
        return str(self)

    def __mod__(self, new_mapping):
        mapping = self.mapping.copy()
        mapping.update(new_mapping)
示例#23
0
from pyramid.i18n import TranslationStringFactory

m2m_groups_tsf = TranslationStringFactory('m2m_groups')


def includeme(config):
    config.scan()
    config.include('m2m_groups.models')
示例#24
0
	Entity,
	LegalEntity,
	PhysicalEntity
)
from netprofile_stashes.models import Stash
from netprofile_rates.models import Rate

from .models import (
	AccessEntity,
	AccessEntityChange,
	AccessEntityLink,
	AccessState
)
from .recaptcha import verify_recaptcha

_ = TranslationStringFactory('netprofile_access')

_re_login = re.compile(r'^[\w\d._-]+$')
_re_email = re.compile(r'^[-.\w]+@(?:[\w\d-]{2,}\.)+\w{2,6}$')

@view_config(route_name='access.cl.home', renderer='netprofile_access:templates/client_home.mak', permission='USAGE')
def client_home(request):
	tpldef = {}
	request.run_hook('access.cl.tpldef', tpldef, request)
	request.run_hook('access.cl.tpldef.home', tpldef, request)
	return tpldef

@notfound_view_config(vhost='client', renderer='netprofile_access:templates/client_error.mak')
def client_notfound(request):
	request.response.status_code = 404
	tpldef = {
示例#25
0
# -*- coding: utf-8 -*-

import logging

from pyramid.i18n import TranslationStringFactory

from c2cgeoportal_commons.models.main import *  # noqa

_ = TranslationStringFactory('waddle-server')
LOG = logging.getLogger(__name__)
示例#26
0
    globs = {
        'url': route_url,
        'current_url': current_route_url,
        'h': helpers,
    }
    if request is not None:
        tmpl_context = request.tmpl_context
        globs['c'] = tmpl_context
        globs['tmpl_context'] = tmpl_context
        globs['_'] = request.translate
        globs['localizer'] = request.localizer
        try:
            globs['session'] = request.session
        except ConfigurationError:
            pass
    event.update(globs)


tsf = TranslationStringFactory('pylonshq')


def add_localizer(event):
    request = event.request
    localizer = get_localizer(request)

    def auto_translate(string):
        return localizer.translate(tsf(string))

    request.localizer = localizer
    request.translate = auto_translate
示例#27
0
from pyramid.i18n import TranslationStringFactory

_ = TranslationStringFactory('Courts-Of-Chaos')


def my_view(request):
    return {'project': 'Courts-Of-Chaos'}
示例#28
0
from pyramid.events import subscriber
from pyramid.events import BeforeRender
from pyramid.httpexceptions import HTTPFound
from pyramid.renderers import render
from pyramid.renderers import render_to_response
from pyramid.response import Response
from pyramid.view import view_config, forbidden_view_config

from pyramid.i18n import TranslationStringFactory, get_localizer
_ = TranslationStringFactory('betty')

from sqlalchemy.sql import func
from sqlalchemy.exc import DBAPIError
from sqlalchemy.orm.exc import NoResultFound

from .models import *
from .models.model import *
from .models import user as __user
from .models.user import User
from .models.item import Item
from .models.box import Box
from .models.transaction import Transaction, BTCDeposit, PurchaseLineItem
from .models.account import Account, VirtualAccount, CashAccount
from .models.event import Event
from .models.announcement import Announcement
from .models.btcdeposit import BtcPendingDeposit
from .models.pool import Pool
from .models.tag import Tag
from .models.ephemeron import Ephemeron
from .models.badscan import BadScan
示例#29
0
文件: post.py 项目: shangxor/assembl
    name='posts',
    path=API_DISCUSSION_PREFIX + '/posts',
    description="Post API following SIOC vocabulary as much as possible",
    renderer='json')

post = Service(name='post',
               path=API_DISCUSSION_PREFIX + '/posts/{id:.+}',
               description="Manipulate a single post",
               renderer="json")

post_read = Service(name='post_read',
                    path=API_DISCUSSION_PREFIX + '/post_read/{id:.+}',
                    description="Signal that a post was read",
                    renderer='json')

_ = TranslationStringFactory('assembl')


@posts.get(permission=P_READ)
def get_posts(request):
    """
    Query interface on posts
    Filters have two forms:
    only_*, is for filters that cannot be reversed (ex: only_synthesis, only_orphan)
    is_*, is for filters that can be reversed (ex:is_unread=true returns only unread message, is_unread=false returns only read messages)
    order: can be chronological, reverse_chronological, popularity
    root_post_id: all posts below the one specified.
    family_post_id: all posts below the one specified, and all its ancestors.
    post_reply_to: replies to a given post
    root_idea_id: all posts associated with the given idea
    ids: explicit message ids.
示例#30
0
文件: views.py 项目: annndrey/npui
from __future__ import (unicode_literals, print_function, absolute_import,
                        division)

import datetime as dt
from dateutil.parser import parse as dparse
from pyramid.i18n import TranslationStringFactory

from netprofile.common.modules import IModuleManager
from netprofile.common.hooks import register_hook
from netprofile.db.connection import DBSession
from netprofile.ext.direct import extdirect_method

from .models import (Entity, EntityType)

_ = TranslationStringFactory('netprofile_entities')


@register_hook('core.dpanetabs.entities.Entity')
@register_hook('core.dpanetabs.entities.PhysicalEntity')
@register_hook('core.dpanetabs.entities.LegalEntity')
@register_hook('core.dpanetabs.entities.StructuralEntity')
@register_hook('core.dpanetabs.entities.ExternalEntity')
def _dpane_entities(tabs, model, req):
    loc = req.localizer
    tabs.extend([{
        'title':
        loc.translate(_('Addresses')),
        'iconCls':
        'ico-mod-address',
        'xtype':