mirror of
https://github.com/JonathanHerrewijnen/calibre-web.git
synced 2024-11-14 15:14:07 +00:00
bbf6d9b026
Bugfix for feeds
- removed categories related and up
- load new books now working
- category random now working
login page is free of non accessible elements
boolean custom column is vivible in UI
books with only with certain languages can be shown
book shelfs can be deleted from UI
Anonymous user view is more resticted
Added browse of series in sidebar
Dependencys in vendor folder are updated to newer versions (licencs files are now present)
Bugfix editing Authors names
Made upload on windows working
531 lines
18 KiB
Python
531 lines
18 KiB
Python
# -*- coding: utf-8 -*-
|
|
"""
|
|
flaskext.babel
|
|
~~~~~~~~~~~~~~
|
|
|
|
Implements i18n/l10n support for Flask applications based on Babel.
|
|
|
|
:copyright: (c) 2013 by Armin Ronacher, Daniel Neuhäuser.
|
|
:license: BSD, see LICENSE for more details.
|
|
"""
|
|
from __future__ import absolute_import
|
|
import os
|
|
|
|
# this is a workaround for a snow leopard bug that babel does not
|
|
# work around :)
|
|
if os.environ.get('LC_CTYPE', '').lower() == 'utf-8':
|
|
os.environ['LC_CTYPE'] = 'en_US.utf-8'
|
|
|
|
from datetime import datetime
|
|
from flask import _request_ctx_stack
|
|
from babel import dates, numbers, support, Locale
|
|
from werkzeug import ImmutableDict
|
|
try:
|
|
from pytz.gae import pytz
|
|
except ImportError:
|
|
from pytz import timezone, UTC
|
|
else:
|
|
timezone = pytz.timezone
|
|
UTC = pytz.UTC
|
|
|
|
from flask_babel._compat import string_types
|
|
|
|
|
|
class Babel(object):
|
|
"""Central controller class that can be used to configure how
|
|
Flask-Babel behaves. Each application that wants to use Flask-Babel
|
|
has to create, or run :meth:`init_app` on, an instance of this class
|
|
after the configuration was initialized.
|
|
"""
|
|
|
|
default_date_formats = ImmutableDict({
|
|
'time': 'medium',
|
|
'date': 'medium',
|
|
'datetime': 'medium',
|
|
'time.short': None,
|
|
'time.medium': None,
|
|
'time.full': None,
|
|
'time.long': None,
|
|
'date.short': None,
|
|
'date.medium': None,
|
|
'date.full': None,
|
|
'date.long': None,
|
|
'datetime.short': None,
|
|
'datetime.medium': None,
|
|
'datetime.full': None,
|
|
'datetime.long': None,
|
|
})
|
|
|
|
def __init__(self, app=None, default_locale='en', default_timezone='UTC',
|
|
date_formats=None, configure_jinja=True):
|
|
self._default_locale = default_locale
|
|
self._default_timezone = default_timezone
|
|
self._date_formats = date_formats
|
|
self._configure_jinja = configure_jinja
|
|
self.app = app
|
|
|
|
if app is not None:
|
|
self.init_app(app)
|
|
|
|
def init_app(self, app):
|
|
"""Set up this instance for use with *app*, if no app was passed to
|
|
the constructor.
|
|
"""
|
|
self.app = app
|
|
app.babel_instance = self
|
|
if not hasattr(app, 'extensions'):
|
|
app.extensions = {}
|
|
app.extensions['babel'] = self
|
|
|
|
app.config.setdefault('BABEL_DEFAULT_LOCALE', self._default_locale)
|
|
app.config.setdefault('BABEL_DEFAULT_TIMEZONE', self._default_timezone)
|
|
if self._date_formats is None:
|
|
self._date_formats = self.default_date_formats.copy()
|
|
|
|
#: a mapping of Babel datetime format strings that can be modified
|
|
#: to change the defaults. If you invoke :func:`format_datetime`
|
|
#: and do not provide any format string Flask-Babel will do the
|
|
#: following things:
|
|
#:
|
|
#: 1. look up ``date_formats['datetime']``. By default ``'medium'``
|
|
#: is returned to enforce medium length datetime formats.
|
|
#: 2. ``date_formats['datetime.medium'] (if ``'medium'`` was
|
|
#: returned in step one) is looked up. If the return value
|
|
#: is anything but `None` this is used as new format string.
|
|
#: otherwise the default for that language is used.
|
|
self.date_formats = self._date_formats
|
|
|
|
self.locale_selector_func = None
|
|
self.timezone_selector_func = None
|
|
|
|
if self._configure_jinja:
|
|
app.jinja_env.filters.update(
|
|
datetimeformat=format_datetime,
|
|
dateformat=format_date,
|
|
timeformat=format_time,
|
|
timedeltaformat=format_timedelta,
|
|
|
|
numberformat=format_number,
|
|
decimalformat=format_decimal,
|
|
currencyformat=format_currency,
|
|
percentformat=format_percent,
|
|
scientificformat=format_scientific,
|
|
)
|
|
app.jinja_env.add_extension('jinja2.ext.i18n')
|
|
app.jinja_env.install_gettext_callables(
|
|
lambda x: get_translations().ugettext(x),
|
|
lambda s, p, n: get_translations().ungettext(s, p, n),
|
|
newstyle=True
|
|
)
|
|
|
|
def localeselector(self, f):
|
|
"""Registers a callback function for locale selection. The default
|
|
behaves as if a function was registered that returns `None` all the
|
|
time. If `None` is returned, the locale falls back to the one from
|
|
the configuration.
|
|
|
|
This has to return the locale as string (eg: ``'de_AT'``, ''`en_US`'')
|
|
"""
|
|
assert self.locale_selector_func is None, \
|
|
'a localeselector function is already registered'
|
|
self.locale_selector_func = f
|
|
return f
|
|
|
|
def timezoneselector(self, f):
|
|
"""Registers a callback function for timezone selection. The default
|
|
behaves as if a function was registered that returns `None` all the
|
|
time. If `None` is returned, the timezone falls back to the one from
|
|
the configuration.
|
|
|
|
This has to return the timezone as string (eg: ``'Europe/Vienna'``)
|
|
"""
|
|
assert self.timezone_selector_func is None, \
|
|
'a timezoneselector function is already registered'
|
|
self.timezone_selector_func = f
|
|
return f
|
|
|
|
|
|
def list_translations(self):
|
|
"""Returns a list of all the locales translations exist for. The
|
|
list returned will be filled with actual locale objects and not just
|
|
strings.
|
|
|
|
.. versionadded:: 0.6
|
|
"""
|
|
dirname = os.path.join(self.app.root_path, 'translations')
|
|
if not os.path.isdir(dirname):
|
|
return []
|
|
result = []
|
|
for folder in os.listdir(dirname):
|
|
locale_dir = os.path.join(dirname, folder, 'LC_MESSAGES')
|
|
if not os.path.isdir(locale_dir):
|
|
continue
|
|
if filter(lambda x: x.endswith('.mo'), os.listdir(locale_dir)):
|
|
result.append(Locale.parse(folder))
|
|
if not result:
|
|
result.append(Locale.parse(self._default_locale))
|
|
return result
|
|
|
|
@property
|
|
def default_locale(self):
|
|
"""The default locale from the configuration as instance of a
|
|
`babel.Locale` object.
|
|
"""
|
|
return Locale.parse(self.app.config['BABEL_DEFAULT_LOCALE'])
|
|
|
|
@property
|
|
def default_timezone(self):
|
|
"""The default timezone from the configuration as instance of a
|
|
`pytz.timezone` object.
|
|
"""
|
|
return timezone(self.app.config['BABEL_DEFAULT_TIMEZONE'])
|
|
|
|
|
|
def get_translations():
|
|
"""Returns the correct gettext translations that should be used for
|
|
this request. This will never fail and return a dummy translation
|
|
object if used outside of the request or if a translation cannot be
|
|
found.
|
|
"""
|
|
ctx = _request_ctx_stack.top
|
|
if ctx is None:
|
|
return None
|
|
translations = getattr(ctx, 'babel_translations', None)
|
|
if translations is None:
|
|
dirname = os.path.join(ctx.app.root_path, 'translations')
|
|
translations = support.Translations.load(dirname, [get_locale()])
|
|
ctx.babel_translations = translations
|
|
return translations
|
|
|
|
|
|
def get_locale():
|
|
"""Returns the locale that should be used for this request as
|
|
`babel.Locale` object. This returns `None` if used outside of
|
|
a request.
|
|
"""
|
|
ctx = _request_ctx_stack.top
|
|
if ctx is None:
|
|
return None
|
|
locale = getattr(ctx, 'babel_locale', None)
|
|
if locale is None:
|
|
babel = ctx.app.extensions['babel']
|
|
if babel.locale_selector_func is None:
|
|
locale = babel.default_locale
|
|
else:
|
|
rv = babel.locale_selector_func()
|
|
if rv is None:
|
|
locale = babel.default_locale
|
|
else:
|
|
locale = Locale.parse(rv)
|
|
ctx.babel_locale = locale
|
|
return locale
|
|
|
|
|
|
def get_timezone():
|
|
"""Returns the timezone that should be used for this request as
|
|
`pytz.timezone` object. This returns `None` if used outside of
|
|
a request.
|
|
"""
|
|
ctx = _request_ctx_stack.top
|
|
tzinfo = getattr(ctx, 'babel_tzinfo', None)
|
|
if tzinfo is None:
|
|
babel = ctx.app.extensions['babel']
|
|
if babel.timezone_selector_func is None:
|
|
tzinfo = babel.default_timezone
|
|
else:
|
|
rv = babel.timezone_selector_func()
|
|
if rv is None:
|
|
tzinfo = babel.default_timezone
|
|
else:
|
|
if isinstance(rv, string_types):
|
|
tzinfo = timezone(rv)
|
|
else:
|
|
tzinfo = rv
|
|
ctx.babel_tzinfo = tzinfo
|
|
return tzinfo
|
|
|
|
|
|
def refresh():
|
|
"""Refreshes the cached timezones and locale information. This can
|
|
be used to switch a translation between a request and if you want
|
|
the changes to take place immediately, not just with the next request::
|
|
|
|
user.timezone = request.form['timezone']
|
|
user.locale = request.form['locale']
|
|
refresh()
|
|
flash(gettext('Language was changed'))
|
|
|
|
Without that refresh, the :func:`~flask.flash` function would probably
|
|
return English text and a now German page.
|
|
"""
|
|
ctx = _request_ctx_stack.top
|
|
for key in 'babel_locale', 'babel_tzinfo', 'babel_translations':
|
|
if hasattr(ctx, key):
|
|
delattr(ctx, key)
|
|
|
|
|
|
def _get_format(key, format):
|
|
"""A small helper for the datetime formatting functions. Looks up
|
|
format defaults for different kinds.
|
|
"""
|
|
babel = _request_ctx_stack.top.app.extensions['babel']
|
|
if format is None:
|
|
format = babel.date_formats[key]
|
|
if format in ('short', 'medium', 'full', 'long'):
|
|
rv = babel.date_formats['%s.%s' % (key, format)]
|
|
if rv is not None:
|
|
format = rv
|
|
return format
|
|
|
|
|
|
def to_user_timezone(datetime):
|
|
"""Convert a datetime object to the user's timezone. This automatically
|
|
happens on all date formatting unless rebasing is disabled. If you need
|
|
to convert a :class:`datetime.datetime` object at any time to the user's
|
|
timezone (as returned by :func:`get_timezone` this function can be used).
|
|
"""
|
|
if datetime.tzinfo is None:
|
|
datetime = datetime.replace(tzinfo=UTC)
|
|
tzinfo = get_timezone()
|
|
return tzinfo.normalize(datetime.astimezone(tzinfo))
|
|
|
|
|
|
def to_utc(datetime):
|
|
"""Convert a datetime object to UTC and drop tzinfo. This is the
|
|
opposite operation to :func:`to_user_timezone`.
|
|
"""
|
|
if datetime.tzinfo is None:
|
|
datetime = get_timezone().localize(datetime)
|
|
return datetime.astimezone(UTC).replace(tzinfo=None)
|
|
|
|
|
|
def format_datetime(datetime=None, format=None, rebase=True):
|
|
"""Return a date formatted according to the given pattern. If no
|
|
:class:`~datetime.datetime` object is passed, the current time is
|
|
assumed. By default rebasing happens which causes the object to
|
|
be converted to the users's timezone (as returned by
|
|
:func:`to_user_timezone`). This function formats both date and
|
|
time.
|
|
|
|
The format parameter can either be ``'short'``, ``'medium'``,
|
|
``'long'`` or ``'full'`` (in which cause the language's default for
|
|
that setting is used, or the default from the :attr:`Babel.date_formats`
|
|
mapping is used) or a format string as documented by Babel.
|
|
|
|
This function is also available in the template context as filter
|
|
named `datetimeformat`.
|
|
"""
|
|
format = _get_format('datetime', format)
|
|
return _date_format(dates.format_datetime, datetime, format, rebase)
|
|
|
|
|
|
def format_date(date=None, format=None, rebase=True):
|
|
"""Return a date formatted according to the given pattern. If no
|
|
:class:`~datetime.datetime` or :class:`~datetime.date` object is passed,
|
|
the current time is assumed. By default rebasing happens which causes
|
|
the object to be converted to the users's timezone (as returned by
|
|
:func:`to_user_timezone`). This function only formats the date part
|
|
of a :class:`~datetime.datetime` object.
|
|
|
|
The format parameter can either be ``'short'``, ``'medium'``,
|
|
``'long'`` or ``'full'`` (in which cause the language's default for
|
|
that setting is used, or the default from the :attr:`Babel.date_formats`
|
|
mapping is used) or a format string as documented by Babel.
|
|
|
|
This function is also available in the template context as filter
|
|
named `dateformat`.
|
|
"""
|
|
if rebase and isinstance(date, datetime):
|
|
date = to_user_timezone(date)
|
|
format = _get_format('date', format)
|
|
return _date_format(dates.format_date, date, format, rebase)
|
|
|
|
|
|
def format_time(time=None, format=None, rebase=True):
|
|
"""Return a time formatted according to the given pattern. If no
|
|
:class:`~datetime.datetime` object is passed, the current time is
|
|
assumed. By default rebasing happens which causes the object to
|
|
be converted to the users's timezone (as returned by
|
|
:func:`to_user_timezone`). This function formats both date and
|
|
time.
|
|
|
|
The format parameter can either be ``'short'``, ``'medium'``,
|
|
``'long'`` or ``'full'`` (in which cause the language's default for
|
|
that setting is used, or the default from the :attr:`Babel.date_formats`
|
|
mapping is used) or a format string as documented by Babel.
|
|
|
|
This function is also available in the template context as filter
|
|
named `timeformat`.
|
|
"""
|
|
format = _get_format('time', format)
|
|
return _date_format(dates.format_time, time, format, rebase)
|
|
|
|
|
|
def format_timedelta(datetime_or_timedelta, granularity='second'):
|
|
"""Format the elapsed time from the given date to now or the given
|
|
timedelta. This currently requires an unreleased development
|
|
version of Babel.
|
|
|
|
This function is also available in the template context as filter
|
|
named `timedeltaformat`.
|
|
"""
|
|
if isinstance(datetime_or_timedelta, datetime):
|
|
datetime_or_timedelta = datetime.utcnow() - datetime_or_timedelta
|
|
return dates.format_timedelta(datetime_or_timedelta, granularity,
|
|
locale=get_locale())
|
|
|
|
|
|
def _date_format(formatter, obj, format, rebase, **extra):
|
|
"""Internal helper that formats the date."""
|
|
locale = get_locale()
|
|
extra = {}
|
|
if formatter is not dates.format_date and rebase:
|
|
extra['tzinfo'] = get_timezone()
|
|
return formatter(obj, format, locale=locale, **extra)
|
|
|
|
|
|
def format_number(number):
|
|
"""Return the given number formatted for the locale in request
|
|
|
|
:param number: the number to format
|
|
:return: the formatted number
|
|
:rtype: unicode
|
|
"""
|
|
locale = get_locale()
|
|
return numbers.format_number(number, locale=locale)
|
|
|
|
|
|
def format_decimal(number, format=None):
|
|
"""Return the given decimal number formatted for the locale in request
|
|
|
|
:param number: the number to format
|
|
:param format: the format to use
|
|
:return: the formatted number
|
|
:rtype: unicode
|
|
"""
|
|
locale = get_locale()
|
|
return numbers.format_decimal(number, format=format, locale=locale)
|
|
|
|
|
|
def format_currency(number, currency, format=None):
|
|
"""Return the given number formatted for the locale in request
|
|
|
|
:param number: the number to format
|
|
:param currency: the currency code
|
|
:param format: the format to use
|
|
:return: the formatted number
|
|
:rtype: unicode
|
|
"""
|
|
locale = get_locale()
|
|
return numbers.format_currency(
|
|
number, currency, format=format, locale=locale
|
|
)
|
|
|
|
|
|
def format_percent(number, format=None):
|
|
"""Return formatted percent value for the locale in request
|
|
|
|
:param number: the number to format
|
|
:param format: the format to use
|
|
:return: the formatted percent number
|
|
:rtype: unicode
|
|
"""
|
|
locale = get_locale()
|
|
return numbers.format_percent(number, format=format, locale=locale)
|
|
|
|
|
|
def format_scientific(number, format=None):
|
|
"""Return value formatted in scientific notation for the locale in request
|
|
|
|
:param number: the number to format
|
|
:param format: the format to use
|
|
:return: the formatted percent number
|
|
:rtype: unicode
|
|
"""
|
|
locale = get_locale()
|
|
return numbers.format_scientific(number, format=format, locale=locale)
|
|
|
|
|
|
def gettext(string, **variables):
|
|
"""Translates a string with the current locale and passes in the
|
|
given keyword arguments as mapping to a string formatting string.
|
|
|
|
::
|
|
|
|
gettext(u'Hello World!')
|
|
gettext(u'Hello %(name)s!', name='World')
|
|
"""
|
|
t = get_translations()
|
|
if t is None:
|
|
return string % variables
|
|
return t.ugettext(string) % variables
|
|
_ = gettext
|
|
|
|
|
|
def ngettext(singular, plural, num, **variables):
|
|
"""Translates a string with the current locale and passes in the
|
|
given keyword arguments as mapping to a string formatting string.
|
|
The `num` parameter is used to dispatch between singular and various
|
|
plural forms of the message. It is available in the format string
|
|
as ``%(num)d`` or ``%(num)s``. The source language should be
|
|
English or a similar language which only has one plural form.
|
|
|
|
::
|
|
|
|
ngettext(u'%(num)d Apple', u'%(num)d Apples', num=len(apples))
|
|
"""
|
|
variables.setdefault('num', num)
|
|
t = get_translations()
|
|
if t is None:
|
|
return (singular if num == 1 else plural) % variables
|
|
return t.ungettext(singular, plural, num) % variables
|
|
|
|
|
|
def pgettext(context, string, **variables):
|
|
"""Like :func:`gettext` but with a context.
|
|
|
|
.. versionadded:: 0.7
|
|
"""
|
|
t = get_translations()
|
|
if t is None:
|
|
return string % variables
|
|
return t.upgettext(context, string) % variables
|
|
|
|
|
|
def npgettext(context, singular, plural, num, **variables):
|
|
"""Like :func:`ngettext` but with a context.
|
|
|
|
.. versionadded:: 0.7
|
|
"""
|
|
variables.setdefault('num', num)
|
|
t = get_translations()
|
|
if t is None:
|
|
return (singular if num == 1 else plural) % variables
|
|
return t.unpgettext(context, singular, plural, num) % variables
|
|
|
|
|
|
def lazy_gettext(string, **variables):
|
|
"""Like :func:`gettext` but the string returned is lazy which means
|
|
it will be translated when it is used as an actual string.
|
|
|
|
Example::
|
|
|
|
hello = lazy_gettext(u'Hello World')
|
|
|
|
@app.route('/')
|
|
def index():
|
|
return unicode(hello)
|
|
"""
|
|
from speaklater import make_lazy_string
|
|
return make_lazy_string(gettext, string, **variables)
|
|
|
|
|
|
def lazy_pgettext(context, string, **variables):
|
|
"""Like :func:`pgettext` but the string returned is lazy which means
|
|
it will be translated when it is used as an actual string.
|
|
|
|
.. versionadded:: 0.7
|
|
"""
|
|
from speaklater import make_lazy_string
|
|
return make_lazy_string(pgettext, context, string, **variables)
|