mirror of
https://github.com/janeczku/calibre-web
synced 2024-08-30 13:02:41 +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
351 lines
11 KiB
Python
351 lines
11 KiB
Python
# -*- coding: utf-8 -*-
|
|
"""
|
|
jinja2.debug
|
|
~~~~~~~~~~~~
|
|
|
|
Implements the debug interface for Jinja. This module does some pretty
|
|
ugly stuff with the Python traceback system in order to achieve tracebacks
|
|
with correct line numbers, locals and contents.
|
|
|
|
:copyright: (c) 2010 by the Jinja Team.
|
|
:license: BSD, see LICENSE for more details.
|
|
"""
|
|
import sys
|
|
import traceback
|
|
from types import TracebackType, CodeType
|
|
from jinja2.utils import missing, internal_code
|
|
from jinja2.exceptions import TemplateSyntaxError
|
|
from jinja2._compat import iteritems, reraise, PY2
|
|
|
|
# on pypy we can take advantage of transparent proxies
|
|
try:
|
|
from __pypy__ import tproxy
|
|
except ImportError:
|
|
tproxy = None
|
|
|
|
|
|
# how does the raise helper look like?
|
|
try:
|
|
exec("raise TypeError, 'foo'")
|
|
except SyntaxError:
|
|
raise_helper = 'raise __jinja_exception__[1]'
|
|
except TypeError:
|
|
raise_helper = 'raise __jinja_exception__[0], __jinja_exception__[1]'
|
|
|
|
|
|
class TracebackFrameProxy(object):
|
|
"""Proxies a traceback frame."""
|
|
|
|
def __init__(self, tb):
|
|
self.tb = tb
|
|
self._tb_next = None
|
|
|
|
@property
|
|
def tb_next(self):
|
|
return self._tb_next
|
|
|
|
def set_next(self, next):
|
|
if tb_set_next is not None:
|
|
try:
|
|
tb_set_next(self.tb, next and next.tb or None)
|
|
except Exception:
|
|
# this function can fail due to all the hackery it does
|
|
# on various python implementations. We just catch errors
|
|
# down and ignore them if necessary.
|
|
pass
|
|
self._tb_next = next
|
|
|
|
@property
|
|
def is_jinja_frame(self):
|
|
return '__jinja_template__' in self.tb.tb_frame.f_globals
|
|
|
|
def __getattr__(self, name):
|
|
return getattr(self.tb, name)
|
|
|
|
|
|
def make_frame_proxy(frame):
|
|
proxy = TracebackFrameProxy(frame)
|
|
if tproxy is None:
|
|
return proxy
|
|
def operation_handler(operation, *args, **kwargs):
|
|
if operation in ('__getattribute__', '__getattr__'):
|
|
return getattr(proxy, args[0])
|
|
elif operation == '__setattr__':
|
|
proxy.__setattr__(*args, **kwargs)
|
|
else:
|
|
return getattr(proxy, operation)(*args, **kwargs)
|
|
return tproxy(TracebackType, operation_handler)
|
|
|
|
|
|
class ProcessedTraceback(object):
|
|
"""Holds a Jinja preprocessed traceback for printing or reraising."""
|
|
|
|
def __init__(self, exc_type, exc_value, frames):
|
|
assert frames, 'no frames for this traceback?'
|
|
self.exc_type = exc_type
|
|
self.exc_value = exc_value
|
|
self.frames = frames
|
|
|
|
# newly concatenate the frames (which are proxies)
|
|
prev_tb = None
|
|
for tb in self.frames:
|
|
if prev_tb is not None:
|
|
prev_tb.set_next(tb)
|
|
prev_tb = tb
|
|
prev_tb.set_next(None)
|
|
|
|
def render_as_text(self, limit=None):
|
|
"""Return a string with the traceback."""
|
|
lines = traceback.format_exception(self.exc_type, self.exc_value,
|
|
self.frames[0], limit=limit)
|
|
return ''.join(lines).rstrip()
|
|
|
|
def render_as_html(self, full=False):
|
|
"""Return a unicode string with the traceback as rendered HTML."""
|
|
from jinja2.debugrenderer import render_traceback
|
|
return u'%s\n\n<!--\n%s\n-->' % (
|
|
render_traceback(self, full=full),
|
|
self.render_as_text().decode('utf-8', 'replace')
|
|
)
|
|
|
|
@property
|
|
def is_template_syntax_error(self):
|
|
"""`True` if this is a template syntax error."""
|
|
return isinstance(self.exc_value, TemplateSyntaxError)
|
|
|
|
@property
|
|
def exc_info(self):
|
|
"""Exception info tuple with a proxy around the frame objects."""
|
|
return self.exc_type, self.exc_value, self.frames[0]
|
|
|
|
@property
|
|
def standard_exc_info(self):
|
|
"""Standard python exc_info for re-raising"""
|
|
tb = self.frames[0]
|
|
# the frame will be an actual traceback (or transparent proxy) if
|
|
# we are on pypy or a python implementation with support for tproxy
|
|
if type(tb) is not TracebackType:
|
|
tb = tb.tb
|
|
return self.exc_type, self.exc_value, tb
|
|
|
|
|
|
def make_traceback(exc_info, source_hint=None):
|
|
"""Creates a processed traceback object from the exc_info."""
|
|
exc_type, exc_value, tb = exc_info
|
|
if isinstance(exc_value, TemplateSyntaxError):
|
|
exc_info = translate_syntax_error(exc_value, source_hint)
|
|
initial_skip = 0
|
|
else:
|
|
initial_skip = 1
|
|
return translate_exception(exc_info, initial_skip)
|
|
|
|
|
|
def translate_syntax_error(error, source=None):
|
|
"""Rewrites a syntax error to please traceback systems."""
|
|
error.source = source
|
|
error.translated = True
|
|
exc_info = (error.__class__, error, None)
|
|
filename = error.filename
|
|
if filename is None:
|
|
filename = '<unknown>'
|
|
return fake_exc_info(exc_info, filename, error.lineno)
|
|
|
|
|
|
def translate_exception(exc_info, initial_skip=0):
|
|
"""If passed an exc_info it will automatically rewrite the exceptions
|
|
all the way down to the correct line numbers and frames.
|
|
"""
|
|
tb = exc_info[2]
|
|
frames = []
|
|
|
|
# skip some internal frames if wanted
|
|
for x in range(initial_skip):
|
|
if tb is not None:
|
|
tb = tb.tb_next
|
|
initial_tb = tb
|
|
|
|
while tb is not None:
|
|
# skip frames decorated with @internalcode. These are internal
|
|
# calls we can't avoid and that are useless in template debugging
|
|
# output.
|
|
if tb.tb_frame.f_code in internal_code:
|
|
tb = tb.tb_next
|
|
continue
|
|
|
|
# save a reference to the next frame if we override the current
|
|
# one with a faked one.
|
|
next = tb.tb_next
|
|
|
|
# fake template exceptions
|
|
template = tb.tb_frame.f_globals.get('__jinja_template__')
|
|
if template is not None:
|
|
lineno = template.get_corresponding_lineno(tb.tb_lineno)
|
|
tb = fake_exc_info(exc_info[:2] + (tb,), template.filename,
|
|
lineno)[2]
|
|
|
|
frames.append(make_frame_proxy(tb))
|
|
tb = next
|
|
|
|
# if we don't have any exceptions in the frames left, we have to
|
|
# reraise it unchanged.
|
|
# XXX: can we backup here? when could this happen?
|
|
if not frames:
|
|
reraise(exc_info[0], exc_info[1], exc_info[2])
|
|
|
|
return ProcessedTraceback(exc_info[0], exc_info[1], frames)
|
|
|
|
|
|
def fake_exc_info(exc_info, filename, lineno):
|
|
"""Helper for `translate_exception`."""
|
|
exc_type, exc_value, tb = exc_info
|
|
|
|
# figure the real context out
|
|
if tb is not None:
|
|
real_locals = tb.tb_frame.f_locals.copy()
|
|
ctx = real_locals.get('context')
|
|
if ctx:
|
|
locals = ctx.get_all()
|
|
else:
|
|
locals = {}
|
|
for name, value in iteritems(real_locals):
|
|
if name.startswith('l_') and value is not missing:
|
|
locals[name[2:]] = value
|
|
|
|
# if there is a local called __jinja_exception__, we get
|
|
# rid of it to not break the debug functionality.
|
|
locals.pop('__jinja_exception__', None)
|
|
else:
|
|
locals = {}
|
|
|
|
# assamble fake globals we need
|
|
globals = {
|
|
'__name__': filename,
|
|
'__file__': filename,
|
|
'__jinja_exception__': exc_info[:2],
|
|
|
|
# we don't want to keep the reference to the template around
|
|
# to not cause circular dependencies, but we mark it as Jinja
|
|
# frame for the ProcessedTraceback
|
|
'__jinja_template__': None
|
|
}
|
|
|
|
# and fake the exception
|
|
code = compile('\n' * (lineno - 1) + raise_helper, filename, 'exec')
|
|
|
|
# if it's possible, change the name of the code. This won't work
|
|
# on some python environments such as google appengine
|
|
try:
|
|
if tb is None:
|
|
location = 'template'
|
|
else:
|
|
function = tb.tb_frame.f_code.co_name
|
|
if function == 'root':
|
|
location = 'top-level template code'
|
|
elif function.startswith('block_'):
|
|
location = 'block "%s"' % function[6:]
|
|
else:
|
|
location = 'template'
|
|
|
|
if PY2:
|
|
code = CodeType(0, code.co_nlocals, code.co_stacksize,
|
|
code.co_flags, code.co_code, code.co_consts,
|
|
code.co_names, code.co_varnames, filename,
|
|
location, code.co_firstlineno,
|
|
code.co_lnotab, (), ())
|
|
else:
|
|
code = CodeType(0, code.co_kwonlyargcount,
|
|
code.co_nlocals, code.co_stacksize,
|
|
code.co_flags, code.co_code, code.co_consts,
|
|
code.co_names, code.co_varnames, filename,
|
|
location, code.co_firstlineno,
|
|
code.co_lnotab, (), ())
|
|
except Exception as e:
|
|
pass
|
|
|
|
# execute the code and catch the new traceback
|
|
try:
|
|
exec(code, globals, locals)
|
|
except:
|
|
exc_info = sys.exc_info()
|
|
new_tb = exc_info[2].tb_next
|
|
|
|
# return without this frame
|
|
return exc_info[:2] + (new_tb,)
|
|
|
|
|
|
def _init_ugly_crap():
|
|
"""This function implements a few ugly things so that we can patch the
|
|
traceback objects. The function returned allows resetting `tb_next` on
|
|
any python traceback object. Do not attempt to use this on non cpython
|
|
interpreters
|
|
"""
|
|
import ctypes
|
|
from types import TracebackType
|
|
|
|
if PY2:
|
|
# figure out size of _Py_ssize_t for Python 2:
|
|
if hasattr(ctypes.pythonapi, 'Py_InitModule4_64'):
|
|
_Py_ssize_t = ctypes.c_int64
|
|
else:
|
|
_Py_ssize_t = ctypes.c_int
|
|
else:
|
|
# platform ssize_t on Python 3
|
|
_Py_ssize_t = ctypes.c_ssize_t
|
|
|
|
# regular python
|
|
class _PyObject(ctypes.Structure):
|
|
pass
|
|
_PyObject._fields_ = [
|
|
('ob_refcnt', _Py_ssize_t),
|
|
('ob_type', ctypes.POINTER(_PyObject))
|
|
]
|
|
|
|
# python with trace
|
|
if hasattr(sys, 'getobjects'):
|
|
class _PyObject(ctypes.Structure):
|
|
pass
|
|
_PyObject._fields_ = [
|
|
('_ob_next', ctypes.POINTER(_PyObject)),
|
|
('_ob_prev', ctypes.POINTER(_PyObject)),
|
|
('ob_refcnt', _Py_ssize_t),
|
|
('ob_type', ctypes.POINTER(_PyObject))
|
|
]
|
|
|
|
class _Traceback(_PyObject):
|
|
pass
|
|
_Traceback._fields_ = [
|
|
('tb_next', ctypes.POINTER(_Traceback)),
|
|
('tb_frame', ctypes.POINTER(_PyObject)),
|
|
('tb_lasti', ctypes.c_int),
|
|
('tb_lineno', ctypes.c_int)
|
|
]
|
|
|
|
def tb_set_next(tb, next):
|
|
"""Set the tb_next attribute of a traceback object."""
|
|
if not (isinstance(tb, TracebackType) and
|
|
(next is None or isinstance(next, TracebackType))):
|
|
raise TypeError('tb_set_next arguments must be traceback objects')
|
|
obj = _Traceback.from_address(id(tb))
|
|
if tb.tb_next is not None:
|
|
old = _Traceback.from_address(id(tb.tb_next))
|
|
old.ob_refcnt -= 1
|
|
if next is None:
|
|
obj.tb_next = ctypes.POINTER(_Traceback)()
|
|
else:
|
|
next = _Traceback.from_address(id(next))
|
|
next.ob_refcnt += 1
|
|
obj.tb_next = ctypes.pointer(next)
|
|
|
|
return tb_set_next
|
|
|
|
|
|
# try to get a tb_set_next implementation if we don't have transparent
|
|
# proxies.
|
|
tb_set_next = None
|
|
if tproxy is None:
|
|
try:
|
|
tb_set_next = _init_ugly_crap()
|
|
except:
|
|
pass
|
|
del _init_ugly_crap
|