class ContentAccessors(object):
"""
A mixin class for response objects that provides a couple of useful
accessors for unittesting.
"""
def xml(self):
"""Get an etree if possible."""
if "xml" not in self.mimetype:
raise AttributeError("Not a XML response (Content-Type: %s)" %
self.mimetype)
for module in [
"xml.etree.ElementTree",
"ElementTree",
"elementtree.ElementTree",
]:
etree = import_string(module, silent=True)
if etree is not None:
return etree.XML(self.body)
raise RuntimeError("You must have ElementTree installed "
"to use TestResponse.xml")
xml = cached_property(xml)
def lxml(self):
"""Get an lxml etree if possible."""
if "html" not in self.mimetype and "xml" not in self.mimetype:
raise AttributeError("Not an HTML/XML response")
from lxml import etree
try:
from lxml.html import fromstring
except ImportError:
fromstring = etree.HTML
if self.mimetype == "text/html":
return fromstring(self.data)
return etree.XML(self.data)
lxml = cached_property(lxml)
def json(self):
"""Get the result of simplejson.loads if possible."""
if "json" not in self.mimetype:
raise AttributeError("Not a JSON response")
try:
from simplejson import loads
except ImportError:
from json import loads
return loads(self.data)
json = cached_property(json)
class ContentAccessors(object):
"""
A mixin class for response objects that provides a couple of useful
accessors for unittesting.
"""
def xml(self):
"""Get an etree if possible."""
if 'xml' not in self.mimetype:
raise AttributeError('Not a XML response (Content-Type: %s)' %
self.mimetype)
for module in [
'xml.etree.ElementTree', 'ElementTree',
'elementtree.ElementTree'
]:
etree = import_string(module, silent=True)
if etree is not None:
return etree.XML(self.body)
raise RuntimeError('You must have ElementTree installed '
'to use TestResponse.xml')
xml = cached_property(xml)
def lxml(self):
"""Get an lxml etree if possible."""
# noinspection PyUnresolvedReferences
if ('html' not in self.mimetype and 'xml' not in self.mimetype):
raise AttributeError('Not an HTML/XML response')
from lxml import etree
try:
from lxml.html import fromstring
except ImportError:
fromstring = etree.HTML
# noinspection PyUnresolvedReferences
if self.mimetype == 'text/html':
return fromstring(self.data)
return etree.XML(self.data)
lxml = cached_property(lxml)
def json(self):
"""Get the result of simplejson.loads if possible."""
if 'json' not in self.mimetype:
raise AttributeError('Not a JSON response')
try:
from simplejson import loads
except ImportError:
from json import loads
return loads(self.data)
json = cached_property(json)
class A:
def _prop(self):
foo.append(42)
return 42
prop = utils.cached_property(_prop, name="prop")
del _prop
class A(object):
def _prop(self):
foo.append(42)
return 42
prop = utils.cached_property(_prop, name='prop')
del _prop
def combined_property(name):
def wrapped(self):
return sum([(getattr(self.yx_profile, name) if self.yx_profile else 0),
(getattr(self.zw_profile, name) if self.zw_profile else 0),
(getattr(self.xm_profile, name) if self.xm_profile else 0),
(getattr(self.hoarder_profile, name)
if self.hoarder_profile else 0)])
wrapped.__name__ = wrapped.func_name = name
return cached_property(wrapped)
class HabitatMixin(object):
subject_name = 'habitat'
blueprint = 'habitat'
parse_record = staticmethod(schemas.parse_habitat)
dataset = cached_property(lambda self: get_dal())
comment_history_view = 'history_consultation.habitat_comments'
@cached_property
def map_url_template(self):
return config.get_config_value('HABITAT_MAP_URL')
@cached_property
def primary_data_url_template(self):
return config.get_config_value('HABITAT_PRIMARY_DATA_URL')
def get_dashboard_url(self, subject):
if flask.current_app.testing:
return flask.request.url
return flask.url_for('dashboard.habitats')
class SpeciesMixin(object):
subject_name = 'species'
blueprint = 'species'
parse_record = staticmethod(schemas.parse_species)
dataset = cached_property(lambda self: get_dal())
comment_history_view = 'history_consultation.species_comments'
@cached_property
def map_url_template(self):
return config.get_config_value('SPECIES_MAP_URL')
@cached_property
def primary_data_url_template(self):
return config.get_config_value('SPECIES_PRIMARY_DATA_URL')
def get_dashboard_url(self, subject):
if flask.current_app.testing:
return flask.request.url
return flask.url_for(
'dashboard.species',
group_code=subject.lu.group_code,
)
class Traceback(object):
"""Wraps a traceback."""
def __init__(self, exc_type, exc_value, tb):
self.exc_type = exc_type
self.exc_value = exc_value
if not isinstance(exc_type, str):
exception_type = exc_type.__name__
if exc_type.__module__ not in ('__builtin__', 'exceptions'):
exception_type = exc_type.__module__ + '.' + exception_type
else:
exception_type = exc_type
self.exception_type = exception_type
# we only add frames to the list that are not hidden. This follows
# the the magic variables as defined by paste.exceptions.collector
self.frames = []
while tb:
self.frames.append(Frame(exc_type, exc_value, tb))
tb = tb.tb_next
def filter_hidden_frames(self):
"""Remove the frames according to the paste spec."""
if not self.frames:
return
new_frames = []
hidden = False
for frame in self.frames:
hide = frame.hide
if hide in ('before', 'before_and_this'):
new_frames = []
hidden = False
if hide == 'before_and_this':
continue
elif hide in ('reset', 'reset_and_this'):
hidden = False
if hide == 'reset_and_this':
continue
elif hide in ('after', 'after_and_this'):
hidden = True
if hide == 'after_and_this':
continue
elif hide or hidden:
continue
new_frames.append(frame)
# if we only have one frame and that frame is from the codeop
# module, remove it.
if len(new_frames) == 1 and self.frames[0].module == 'codeop':
del self.frames[:]
# if the last frame is missing something went terrible wrong :(
elif self.frames[-1] in new_frames:
self.frames[:] = new_frames
def is_syntax_error(self):
"""Is it a syntax error?"""
return isinstance(self.exc_value, SyntaxError)
is_syntax_error = property(is_syntax_error)
def exception(self):
"""String representation of the exception."""
buf = traceback.format_exception_only(self.exc_type, self.exc_value)
rv = ''.join(buf).strip()
return rv.decode('utf-8', 'replace') if PY2 else rv
exception = property(exception)
def log(self, logfile=None):
"""Log the ASCII traceback into a file object."""
if logfile is None:
logfile = sys.stderr
tb = self.plaintext.rstrip() + u'\n'
if PY2:
tb = tb.encode('utf-8', 'replace')
logfile.write(tb)
def paste(self):
"""Create a paste and return the paste id."""
data = json.dumps({
'description': 'Werkzeug Internal Server Error',
'public': False,
'files': {
'traceback.txt': {
'content': self.plaintext
}
}
}).encode('utf-8')
try:
from urllib2 import urlopen
except ImportError:
from urllib.request import urlopen
rv = urlopen('https://api.github.com/gists', data=data)
resp = json.loads(rv.read().decode('utf-8'))
rv.close()
return {
'url': resp['html_url'],
'id': resp['id']
}
def render_summary(self, include_title=True):
"""Render the traceback for the interactive console."""
title = ''
frames = []
classes = ['traceback']
if not self.frames:
classes.append('noframe-traceback')
if include_title:
if self.is_syntax_error:
title = u'Syntax Error'
else:
title = u'Traceback <em>(most recent call last)</em>:'
for frame in self.frames:
frames.append(u'<li%s>%s' % (
frame.info and u' title="%s"' % escape(frame.info) or u'',
frame.render()
))
if self.is_syntax_error:
description_wrapper = u'<pre class=syntaxerror>%s</pre>'
else:
description_wrapper = u'<blockquote>%s</blockquote>'
return SUMMARY_HTML % {
'classes': u' '.join(classes),
'title': title and u'<h3>%s</h3>' % title or u'',
'frames': u'\n'.join(frames),
'description': description_wrapper % escape(self.exception)
}
def render_full(self, evalex=False, secret=None):
"""Render the Full HTML page with the traceback info."""
exc = escape(self.exception)
return PAGE_HTML % {
'evalex': evalex and 'true' or 'false',
'console': 'false',
'title': exc,
'exception': exc,
'exception_type': escape(self.exception_type),
'summary': self.render_summary(include_title=False),
'plaintext': self.plaintext,
'plaintext_cs': re.sub('-{2,}', '-', self.plaintext),
'traceback_id': self.id,
'secret': secret
}
def generate_plaintext_traceback(self):
"""Like the plaintext attribute but returns a generator"""
yield u'Traceback (most recent call last):'
for frame in self.frames:
yield u' File "%s", line %s, in %s' % (
frame.filename,
frame.lineno,
frame.function_name
)
yield u' ' + frame.current_line.strip()
yield self.exception
def plaintext(self):
return u'\n'.join(self.generate_plaintext_traceback())
plaintext = cached_property(plaintext)
id = property(lambda x: id(x))
class A:
def prop(self):
foo.append(42)
return 42
prop = utils.cached_property(prop)
class Traceback(object):
"""Wraps a traceback."""
def __init__(self, exc_type, exc_value, tb):
self.exc_type = exc_type
self.exc_value = exc_value
if not isinstance(exc_type, str):
exception_type = exc_type.__name__
if exc_type.__module__ not in ('__builtin__', 'exceptions'):
exception_type = exc_type.__module__ + '.' + exception_type
else:
exception_type = exc_type
self.exception_type = exception_type
# we only add frames to the list that are not hidden. This follows
# the the magic variables as defined by paste.exceptions.collector
self.frames = []
while tb:
self.frames.append(Frame(exc_type, exc_value, tb))
tb = tb.tb_next
def filter_hidden_frames(self):
"""Remove the frames according to the paste spec."""
new_frames = []
hidden = False
for frame in self.frames:
hide = frame.hide
if hide in ('before', 'before_and_this'):
new_frames = []
hidden = False
if hide == 'before_and_this':
continue
elif hide in ('reset', 'reset_and_this'):
hidden = False
if hide == 'reset_and_this':
continue
elif hide in ('after', 'after_and_this'):
hidden = True
if hide == 'after_and_this':
continue
elif hide or hidden:
continue
new_frames.append(frame)
# if the last frame is missing something went terrible wrong :(
if self.frames[-1] in new_frames:
self.frames[:] = new_frames
def is_syntax_error(self):
"""Is it a syntax error?"""
return isinstance(self.exc_value, SyntaxError)
is_syntax_error = property(is_syntax_error)
def exception(self):
"""String representation of the exception."""
buf = traceback.format_exception_only(self.exc_type, self.exc_value)
return ''.join(buf).strip().decode('utf-8', 'replace')
exception = property(exception)
def log(self, logfile=None):
"""Log the ASCII traceback into a file object."""
if logfile is None:
logfile = sys.stderr
tb = self.plaintext.encode('utf-8', 'replace').rstrip() + '\n'
logfile.write(tb)
def paste(self):
"""Create a paste and return the paste id."""
from xmlrpclib import ServerProxy
srv = ServerProxy('http://paste.pocoo.org/xmlrpc/')
return srv.pastes.newPaste('pytb', self.plaintext)
def render_summary(self, include_title=True):
"""Render the traceback for the interactive console."""
return render_template('traceback_summary.html',
traceback=self,
include_title=include_title)
def render_full(self, evalex=False):
"""Render the Full HTML page with the traceback info."""
return render_template('traceback_full.html',
traceback=self,
evalex=evalex)
def plaintext(self):
return render_template('traceback_plaintext.html', traceback=self)
plaintext = cached_property(plaintext)
id = property(lambda x: id(x))
)
),
),
)
# One-way flags (no elegant way to do a reverse query)
has_boards = UserFlag(
'admin',
__("Has a sub-board"),
lambda user: Board.query.filter(
Board.userid.in_(user.allowner_ids())
).notempty(),
None,
)
def _user_flags(self):
cache_key = 'user/flags/' + str(self.id)
flags = cache.get(cache_key)
if not flags:
flags = {}
for key, func in UserFlags.__dict__.items():
if isinstance(func, UserFlag):
flags[key] = func.for_user(self)
cache.set(cache_key, flags, timeout=3600) # Cache for one hour
return flags
User.flags = cached_property(_user_flags)
def decorator(class_):
for name, factory in properties.iteritems():
def new(self, factory=factory):
return factory()
setattr(class_, name, cached_property(new, name))
return class_
class Traceback(object):
def __init__(self, exc_type, exc_value, tb):
self.exc_type = exc_type
self.exc_value = exc_value
if not isinstance(exc_type, str):
exception_type = exc_type.__name__
if exc_type.__module__ not in ('__builtin__', 'exceptions'):
exception_type = exc_type.__module__ + '.' + exception_type
else:
exception_type = exc_type
self.exception_type = exception_type
self.frames = []
while tb:
self.frames.append(Frame(exc_type, exc_value, tb))
tb = tb.tb_next
def filter_hidden_frames(self):
new_frames = []
hidden = False
for frame in self.frames:
hide = frame.hide
if hide in ('before', 'before_and_this'):
new_frames = []
hidden = False
if hide == 'before_and_this':
continue
elif hide in ('reset', 'reset_and_this'):
hidden = False
if hide == 'reset_and_this':
continue
elif hide in ('after', 'after_and_this'):
hidden = True
if hide == 'after_and_this':
continue
elif hide or hidden:
continue
new_frames.append(frame)
if self.frames[-1] in new_frames:
self.frames[:] = new_frames
def is_syntax_error(self):
return isinstance(self.exc_value, SyntaxError)
is_syntax_error = property(is_syntax_error)
def exception(self):
buf = traceback.format_exception_only(self.exc_type, self.exc_value)
return ''.join(buf).strip().decode('utf-8', 'replace')
exception = property(exception)
def log(self, logfile=None):
if logfile is None:
logfile = sys.stderr
tb = self.plaintext.encode('utf-8', 'replace').rstrip() + '\n'
logfile.write(tb)
def paste(self):
from xmlrpclib import ServerProxy
srv = ServerProxy('http://paste.pocoo.org/xmlrpc/')
return srv.pastes.newPaste('pytb', self.plaintext)
def render_summary(self, include_title=True):
return render_template('traceback_summary.html',
traceback=self,
include_title=include_title)
def render_full(self, evalex=False):
return render_template('traceback_full.html',
traceback=self,
evalex=evalex)
def plaintext(self):
return render_template('traceback_plaintext.html', traceback=self)
plaintext = cached_property(plaintext)
id = property(lambda x: id(x))
class Traceback(object):
"""Wraps a traceback."""
def __init__(self, exc_type, exc_value, tb):
self.exc_type = exc_type
self.exc_value = exc_value
if not isinstance(exc_type, str):
exception_type = exc_type.__name__
if exc_type.__module__ not in ("__builtin__", "exceptions"):
exception_type = exc_type.__module__ + "." + exception_type
else:
exception_type = exc_type
self.exception_type = exception_type
# we only add frames to the list that are not hidden. This follows
# the the magic variables as defined by paste.exceptions.collector
self.frames = []
while tb:
self.frames.append(Frame(exc_type, exc_value, tb))
tb = tb.tb_next
def filter_hidden_frames(self):
"""Remove the frames according to the paste spec."""
if not self.frames:
return
new_frames = []
hidden = False
for frame in self.frames:
hide = frame.hide
if hide in ("before", "before_and_this"):
new_frames = []
hidden = False
if hide == "before_and_this":
continue
elif hide in ("reset", "reset_and_this"):
hidden = False
if hide == "reset_and_this":
continue
elif hide in ("after", "after_and_this"):
hidden = True
if hide == "after_and_this":
continue
elif hide or hidden:
continue
new_frames.append(frame)
# if we only have one frame and that frame is from the codeop
# module, remove it.
if len(new_frames) == 1 and self.frames[0].module == "codeop":
del self.frames[:]
# if the last frame is missing something went terrible wrong :(
elif self.frames[-1] in new_frames:
self.frames[:] = new_frames
def is_syntax_error(self):
"""Is it a syntax error?"""
return isinstance(self.exc_value, SyntaxError)
is_syntax_error = property(is_syntax_error)
def exception(self):
"""String representation of the exception."""
buf = traceback.format_exception_only(self.exc_type, self.exc_value)
rv = "".join(buf).strip()
return rv.decode("utf-8", "replace") if PY2 else rv
exception = property(exception)
def log(self, logfile=None):
"""Log the ASCII traceback into a file object."""
if logfile is None:
logfile = sys.stderr
tb = self.plaintext.rstrip() + u"\n"
if PY2:
tb = tb.encode("utf-8", "replace")
logfile.write(tb)
def paste(self):
"""Create a paste and return the paste id."""
data = json.dumps({
"description": "Werkzeug Internal Server Error",
"public": False,
"files": {
"traceback.txt": {
"content": self.plaintext
}
},
}).encode("utf-8")
try:
from urllib2 import urlopen
except ImportError:
from urllib.request import urlopen
rv = urlopen("https://api.github.com/gists", data=data)
resp = json.loads(rv.read().decode("utf-8"))
rv.close()
return {"url": resp["html_url"], "id": resp["id"]}
def render_summary(self, include_title=True):
"""Render the traceback for the interactive console."""
title = ""
frames = []
classes = ["traceback"]
if not self.frames:
classes.append("noframe-traceback")
if include_title:
if self.is_syntax_error:
title = u"Syntax Error"
else:
title = u"Traceback <em>(most recent call last)</em>:"
for frame in self.frames:
frames.append(u"<li%s>%s" % (
frame.info and u' title="%s"' % escape(frame.info) or u"",
frame.render(),
))
if self.is_syntax_error:
description_wrapper = u"<pre class=syntaxerror>%s</pre>"
else:
description_wrapper = u"<blockquote>%s</blockquote>"
return SUMMARY_HTML % {
"classes": u" ".join(classes),
"title": title and u"<h3>%s</h3>" % title or u"",
"frames": u"\n".join(frames),
"description": description_wrapper % escape(self.exception),
}
def render_full(self, evalex=False, secret=None, evalex_trusted=True):
"""Render the Full HTML page with the traceback info."""
exc = escape(self.exception)
return PAGE_HTML % {
"evalex": evalex and "true" or "false",
"evalex_trusted": evalex_trusted and "true" or "false",
"console": "false",
"title": exc,
"exception": exc,
"exception_type": escape(self.exception_type),
"summary": self.render_summary(include_title=False),
"plaintext": escape(self.plaintext),
"plaintext_cs": re.sub("-{2,}", "-", self.plaintext),
"traceback_id": self.id,
"secret": secret,
}
def generate_plaintext_traceback(self):
"""Like the plaintext attribute but returns a generator"""
yield u"Traceback (most recent call last):"
for frame in self.frames:
yield u' File "%s", line %s, in %s' % (
frame.filename,
frame.lineno,
frame.function_name,
)
yield u" " + frame.current_line.strip()
yield self.exception
def plaintext(self):
return u"\n".join(self.generate_plaintext_traceback())
plaintext = cached_property(plaintext)
id = property(lambda x: id(x))
