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'),
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',
# 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):
# -*- 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)
#
# 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)
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}
# -*- 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.
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)
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"))
def _makeOne(self, *arg, **kw):
from pyramid.i18n import TranslationStringFactory
return TranslationStringFactory(*arg, **kw)
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')
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 = \
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 (
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."""
from pyramid.i18n import TranslationStringFactory
_ = TranslationStringFactory(__package__)
MISSING_PARAMETER = _('Missing parameter')
NOT_LOGGED_IN = _('You must be logged in to do that!')
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',
]
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)
#
# 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)
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')
#
# 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)
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):
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)
from pyramid.i18n import TranslationStringFactory
m2m_groups_tsf = TranslationStringFactory('m2m_groups')
def includeme(config):
config.scan()
config.include('m2m_groups.models')
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 = {
# -*- coding: utf-8 -*-
import logging
from pyramid.i18n import TranslationStringFactory
from c2cgeoportal_commons.models.main import * # noqa
_ = TranslationStringFactory('waddle-server')
LOG = logging.getLogger(__name__)
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
from pyramid.i18n import TranslationStringFactory
_ = TranslationStringFactory('Courts-Of-Chaos')
def my_view(request):
return {'project': 'Courts-Of-Chaos'}
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
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.
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':
