desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
'Noting row boundaries, see if we can return to the starting point.'
| def scan_up(self, top, left, bottom, right):
| rowseps = {}
for i in range((bottom - 1), top, (-1)):
if (self.block[i][left] == '+'):
rowseps[i] = [left]
elif (self.block[i][left] != '|'):
return None
return rowseps
|
'From the data collected by `scan_cell()`, convert to the final data
structure.'
| def structure_from_cells(self):
| rowseps = self.rowseps.keys()
rowseps.sort()
rowindex = {}
for i in range(len(rowseps)):
rowindex[rowseps[i]] = i
colseps = self.colseps.keys()
colseps.sort()
colindex = {}
for i in range(len(colseps)):
colindex[colseps[i]] = i
colspecs = [((colseps[i] - colseps[(i - ... |
'First determine the column boundaries from the top border, then
process rows. Each row may consist of multiple lines; accumulate
lines until a row is complete. Call `self.parse_row` to finish the
job.'
| def parse_table(self):
| self.columns = self.parse_columns(self.block[0], 0)
self.border_end = self.columns[(-1)][1]
(firststart, firstend) = self.columns[0]
offset = 1
start = 1
text_found = None
while (offset < len(self.block)):
line = self.block[offset]
if self.span_pat.match(line):
se... |
'Given a column span underline, return a list of (begin, end) pairs.'
| def parse_columns(self, line, offset):
| cols = []
end = 0
while 1:
begin = line.find('-', end)
end = line.find(' ', begin)
if (begin < 0):
break
if (end < 0):
end = len(line)
cols.append((begin, end))
if self.columns:
if (cols[(-1)][1] != self.border_end):
... |
'Given the text `lines` of a row, parse it and append to `self.table`.
The row is parsed according to the current column spec (either
`spanline` if provided or `self.columns`). For each column, extract
text from each line, and check for text in column margins. Finally,
adjust for insigificant whitespace.'
| def parse_row(self, lines, start, spanline=None):
| if (not (lines or spanline)):
return
if spanline:
columns = self.parse_columns(*spanline)
span_offset = spanline[1]
else:
columns = self.columns[:]
span_offset = start
self.check_columns(lines, start, columns)
row = self.init_row(columns, start)
for i in r... |
'Check for text in column margins and text overflow in the last column.
Raise TableMarkupError if anything but whitespace is in column margins.
Adjust the end value for the last column if there is text overflow.'
| def check_columns(self, lines, first_line, columns):
| columns.append((sys.maxint, None))
lastcol = (len(columns) - 2)
for i in range((len(columns) - 1)):
(start, end) = columns[i]
nextstart = columns[(i + 1)][0]
offset = 0
for line in lines:
if ((i == lastcol) and line[end:].strip()):
text = line[star... |
'Test a token against a token expression. This can either be a
token type or ``\'token_type:token_value\'``. This can only test
against string values and types.'
| def test(self, expr):
| if (self.type == expr):
return True
elif (':' in expr):
return (expr.split(':', 1) == [self.type, self.value])
return False
|
'Test against multiple token expressions.'
| def test_any(self, *iterable):
| for expr in iterable:
if self.test(expr):
return True
return False
|
'Push a token back to the stream.'
| def push(self, token):
| self._pushed.append(token)
|
'Look at the next token.'
| def look(self):
| old_token = next(self)
result = self.current
self.push(result)
self.current = old_token
return result
|
'Got n tokens ahead.'
| def skip(self, n=1):
| for x in xrange(n):
next(self)
|
'Perform the token test and return the token if it matched.
Otherwise the return value is `None`.'
| def next_if(self, expr):
| if self.current.test(expr):
return next(self)
|
'Like :meth:`next_if` but only returns `True` or `False`.'
| def skip_if(self, expr):
| return (self.next_if(expr) is not None)
|
'Go one token ahead and return the old one'
| def next(self):
| rv = self.current
if self._pushed:
self.current = self._pushed.popleft()
elif (self.current.type is not TOKEN_EOF):
try:
self.current = self._next()
except StopIteration:
self.close()
return rv
|
'Close the stream.'
| def close(self):
| self.current = Token(self.current.lineno, TOKEN_EOF, '')
self._next = None
self.closed = True
|
'Expect a given token type and return it. This accepts the same
argument as :meth:`jinja2.lexer.Token.test`.'
| def expect(self, expr):
| if (not self.current.test(expr)):
if (':' in expr):
expr = expr.split(':')[1]
if (self.current.type is TOKEN_EOF):
raise TemplateSyntaxError(('unexpected end of template, expected %r.' % expr), self.current.lineno, self.name, self.filename)
raise Templa... |
'Called for strings and template data to normlize it to unicode.'
| def _normalize_newlines(self, value):
| return newline_re.sub(self.newline_sequence, value)
|
'Calls tokeniter + tokenize and wraps it in a token stream.'
| def tokenize(self, source, name=None, filename=None, state=None):
| stream = self.tokeniter(source, name, filename, state)
return TokenStream(self.wrap(stream, name, filename), name, filename)
|
'This is called with the stream as returned by `tokenize` and wraps
every token in a :class:`Token` and converts the value.'
| def wrap(self, stream, name=None, filename=None):
| for (lineno, token, value) in stream:
if (token in ignored_tokens):
continue
elif (token == 'linestatement_begin'):
token = 'block_begin'
elif (token == 'linestatement_end'):
token = 'block_end'
elif (token in ('raw_begin', 'raw_end')):
... |
'This method tokenizes the text and returns the tokens in a
generator. Use this method if you just want to tokenize a template.'
| def tokeniter(self, source, name, filename=None, state=None):
| source = '\n'.join(unicode(source).splitlines())
pos = 0
lineno = 1
stack = ['root']
if ((state is not None) and (state != 'root')):
assert (state in ('variable', 'block')), 'invalid state'
stack.append((state + '_begin'))
else:
state = 'root'
statetokens = self.ru... |
'Unescape markup again into an unicode string. This also resolves
known HTML4 and XHTML entities:
>>> Markup("Main » <em>About</em>").unescape()
u\'Main \xbb <em>About</em>\''
| def unescape(self):
| from jinja2.constants import HTML_ENTITIES
def handle_match(m):
name = m.group(1)
if (name in HTML_ENTITIES):
return unichr(HTML_ENTITIES[name])
try:
if (name[:2] in ('#x', '#X')):
return unichr(int(name[2:], 16))
elif name.startswith('... |
'Unescape markup into an unicode string and strip all tags. This
also resolves known HTML4 and XHTML entities. Whitespace is
normalized to one:
>>> Markup("Main » <em>About</em>").striptags()
u\'Main \xbb About\''
| def striptags(self):
| stripped = u' '.join(_striptags_re.sub('', self).split())
return Markup(stripped).unescape()
|
'Escape the string. Works like :func:`escape` with the difference
that for subclasses of :class:`Markup` this function would return the
correct subclass.'
| @classmethod
def escape(cls, s):
| rv = escape(s)
if (rv.__class__ is not cls):
return cls(rv)
return rv
|
'Python 2.4 compatibility.'
| def _remove(self, obj):
| for (idx, item) in enumerate(self._queue):
if (item == obj):
del self._queue[idx]
break
|
'Return an shallow copy of the instance.'
| def copy(self):
| rv = self.__class__(self.capacity)
rv._mapping.update(self._mapping)
rv._queue = deque(self._queue)
return rv
|
'Return an item from the cache dict or `default`'
| def get(self, key, default=None):
| try:
return self[key]
except KeyError:
return default
|
'Set `default` if the key is not in the cache otherwise
leave unchanged. Return the value of this key.'
| def setdefault(self, key, default=None):
| try:
return self[key]
except KeyError:
self[key] = default
return default
|
'Clear the cache.'
| def clear(self):
| self._wlock.acquire()
try:
self._mapping.clear()
self._queue.clear()
finally:
self._wlock.release()
|
'Check if a key exists in this cache.'
| def __contains__(self, key):
| return (key in self._mapping)
|
'Return the current size of the cache.'
| def __len__(self):
| return len(self._mapping)
|
'Get an item from the cache. Moves the item up so that it has the
highest priority then.
Raise an `KeyError` if it does not exist.'
| def __getitem__(self, key):
| rv = self._mapping[key]
if (self._queue[(-1)] != key):
try:
self._remove(key)
except ValueError:
pass
self._append(key)
return rv
|
'Sets the value for an item. Moves the item up so that it
has the highest priority then.'
| def __setitem__(self, key, value):
| self._wlock.acquire()
try:
if (key in self._mapping):
self._remove(key)
elif (len(self._mapping) == self.capacity):
del self._mapping[self._popleft()]
self._append(key)
self._mapping[key] = value
finally:
self._wlock.release()
|
'Remove an item from the cache dict.
Raise an `KeyError` if it does not exist.'
| def __delitem__(self, key):
| self._wlock.acquire()
try:
del self._mapping[key]
try:
self._remove(key)
except ValueError:
pass
finally:
self._wlock.release()
|
'Return a list of items.'
| def items(self):
| result = [(key, self._mapping[key]) for key in list(self._queue)]
result.reverse()
return result
|
'Iterate over all items.'
| def iteritems(self):
| return iter(self.items())
|
'Return a list of all values.'
| def values(self):
| return [x[1] for x in self.items()]
|
'Iterate over all values.'
| def itervalue(self):
| return iter(self.values())
|
'Return a list of all keys ordered by most recent usage.'
| def keys(self):
| return list(self)
|
'Iterate over all keys in the cache dict, ordered by
the most recent usage.'
| def iterkeys(self):
| return reversed(tuple(self._queue))
|
'Iterate over the values in the cache dict, oldest items
coming first.'
| def __reversed__(self):
| return iter(tuple(self._queue))
|
'Resets the cycle.'
| def reset(self):
| self.pos = 0
|
'Returns the current item.'
| @property
def current(self):
| return self.items[self.pos]
|
'Goes one item ahead and returns it.'
| def next(self):
| rv = self.current
self.pos = ((self.pos + 1) % len(self.items))
return rv
|
'Create a copy of this extension bound to another environment.'
| def bind(self, environment):
| rv = object.__new__(self.__class__)
rv.__dict__.update(self.__dict__)
rv.environment = environment
return rv
|
'This method is called before the actual lexing and can be used to
preprocess the source. The `filename` is optional. The return value
must be the preprocessed source.'
| def preprocess(self, source, name, filename=None):
| return source
|
'It\'s passed a :class:`~jinja2.lexer.TokenStream` that can be used
to filter tokens returned. This method has to return an iterable of
:class:`~jinja2.lexer.Token`\s, but it doesn\'t have to return a
:class:`~jinja2.lexer.TokenStream`.
In the `ext` folder of the Jinja2 source distribution there is a file
called `inli... | def filter_stream(self, stream):
| return stream
|
'If any of the :attr:`tags` matched this method is called with the
parser as first argument. The token the parser stream is pointing at
is the name token that matched. This method has to return one or a
list of multiple nodes.'
| def parse(self, parser):
| raise NotImplementedError()
|
'Return an attribute node for the current extension. This is useful
to pass constants on extensions to generated template code::
self.attr(\'_my_attribute\', lineno=lineno)'
| def attr(self, name, lineno=None):
| return nodes.ExtensionAttribute(self.identifier, name, lineno=lineno)
|
'Call a method of the extension. This is a shortcut for
:meth:`attr` + :class:`jinja2.nodes.Call`.'
| def call_method(self, name, args=None, kwargs=None, dyn_args=None, dyn_kwargs=None, lineno=None):
| if (args is None):
args = []
if (kwargs is None):
kwargs = []
return nodes.Call(self.attr(name, lineno=lineno), args, kwargs, dyn_args, dyn_kwargs, lineno=lineno)
|
'Parse a translatable tag.'
| def parse(self, parser):
| lineno = next(parser.stream).lineno
plural_expr = None
variables = {}
while (parser.stream.current.type != 'block_end'):
if variables:
parser.stream.expect('comma')
if parser.stream.skip_if('colon'):
break
name = parser.stream.expect('name')
if (na... |
'Parse until the next block tag with a given name.'
| def _parse_block(self, parser, allow_pluralize):
| referenced = []
buf = []
while 1:
if (parser.stream.current.type == 'data'):
buf.append(parser.stream.current.value.replace('%', '%%'))
next(parser.stream)
elif (parser.stream.current.type == 'variable_begin'):
next(parser.stream)
name = parser... |
'Generates a useful node from the data provided.'
| def _make_node(self, singular, plural, variables, plural_expr):
| if (plural_expr is None):
gettext = nodes.Name('gettext', 'load')
node = nodes.Call(gettext, [nodes.Const(singular)], [], None, None)
else:
ngettext = nodes.Name('ngettext', 'load')
node = nodes.Call(ngettext, [nodes.Const(singular), nodes.Const(plural), plural_expr], [], None, N... |
'This method iterates over all fields that are defined and yields
``(key, value)`` tuples. Per default all fields are returned, but
it\'s possible to limit that to some fields by providing the `only`
parameter or to exclude some using the `exclude` parameter. Both
should be sets or tuples of field names.'
| def iter_fields(self, exclude=None, only=None):
| for name in self.fields:
if ((exclude is only is None) or ((exclude is not None) and (name not in exclude)) or ((only is not None) and (name in only))):
try:
(yield (name, getattr(self, name)))
except AttributeError:
pass
|
'Iterates over all direct child nodes of the node. This iterates
over all fields and yields the values of they are nodes. If the value
of a field is a list all the nodes in that list are returned.'
| def iter_child_nodes(self, exclude=None, only=None):
| for (field, item) in self.iter_fields(exclude, only):
if isinstance(item, list):
for n in item:
if isinstance(n, Node):
(yield n)
elif isinstance(item, Node):
(yield item)
|
'Find the first node of a given type. If no such node exists the
return value is `None`.'
| def find(self, node_type):
| for result in self.find_all(node_type):
return result
|
'Find all the nodes of a given type. If the type is a tuple,
the check is performed for any of the tuple items.'
| def find_all(self, node_type):
| for child in self.iter_child_nodes():
if isinstance(child, node_type):
(yield child)
for result in child.find_all(node_type):
(yield result)
|
'Reset the context of a node and all child nodes. Per default the
parser will all generate nodes that have a \'load\' context as it\'s the
most common one. This method is used in the parser to set assignment
targets and other nodes to a store context.'
| def set_ctx(self, ctx):
| todo = deque([self])
while todo:
node = todo.popleft()
if ('ctx' in node.fields):
node.ctx = ctx
todo.extend(node.iter_child_nodes())
return self
|
'Set the line numbers of the node and children.'
| def set_lineno(self, lineno, override=False):
| todo = deque([self])
while todo:
node = todo.popleft()
if ('lineno' in node.attributes):
if ((node.lineno is None) or override):
node.lineno = lineno
todo.extend(node.iter_child_nodes())
return self
|
'Set the environment for all nodes.'
| def set_environment(self, environment):
| todo = deque([self])
while todo:
node = todo.popleft()
node.environment = environment
todo.extend(node.iter_child_nodes())
return self
|
'Return the value of the expression as constant or raise
:exc:`Impossible` if this was not possible:
>>> Add(Const(23), Const(42)).as_const()
65
>>> Add(Const(23), Name(\'var\', \'load\')).as_const()
Traceback (most recent call last):
Impossible
This requires the `environment` attribute of all nodes to be
set to the en... | def as_const(self):
| raise Impossible()
|
'Check if it\'s possible to assign something to this node.'
| def can_assign(self):
| return False
|
'Return a const object if the value is representable as
constant value in the generated code, otherwise it will raise
an `Impossible` exception.'
| @classmethod
def from_untrusted(cls, value, lineno=None, environment=None):
| from compiler import has_safe_repr
if (not has_safe_repr(value)):
raise Impossible()
return cls(value, lineno=lineno, environment=environment)
|
'Remember all undeclared identifiers.'
| def pull_locals(self, frame):
| self.undeclared_identifiers.update(frame.identifiers.undeclared)
|
'Render a parent block.'
| def super(self, name, current):
| try:
blocks = self.blocks[name]
index = (blocks.index(current) + 1)
blocks[index]
except LookupError:
return self.environment.undefined(('there is no parent block called %r.' % name), name='super')
return BlockReference(name, self, blocks, index)
|
'Returns an item from the template context, if it doesn\'t exist
`default` is returned.'
| def get(self, key, default=None):
| try:
return self[key]
except KeyError:
return default
|
'Looks up a variable like `__getitem__` or `get` but returns an
:class:`Undefined` object with the name of the name looked up.'
| def resolve(self, key):
| if (key in self.vars):
return self.vars[key]
if (key in self.parent):
return self.parent[key]
return self.environment.undefined(name=key)
|
'Get a new dict with the exported variables.'
| def get_exported(self):
| return dict(((k, self.vars[k]) for k in self.exported_vars))
|
'Return a copy of the complete context as dict including the
exported variables.'
| def get_all(self):
| return dict(self.parent, **self.vars)
|
'Call the callable with the arguments and keyword arguments
provided but inject the active context or environment as first
argument if the callable is a :func:`contextfunction` or
:func:`environmentfunction`.'
| @internalcode
def call(__self, __obj, *args, **kwargs):
| if __debug__:
__traceback_hide__ = True
if isinstance(__obj, _context_function_types):
if getattr(__obj, 'contextfunction', 0):
args = ((__self,) + args)
elif getattr(__obj, 'environmentfunction', 0):
args = ((__self.environment,) + args)
return __obj(*args, *... |
'Internal helper function to create a derived context.'
| def derived(self, locals=None):
| context = new_context(self.environment, self.name, {}, self.parent, True, None, locals)
context.blocks.update(((k, list(v)) for (k, v) in self.blocks.iteritems()))
return context
|
'Lookup a variable or raise `KeyError` if the variable is
undefined.'
| def __getitem__(self, key):
| item = self.resolve(key)
if isinstance(item, Undefined):
raise KeyError(key)
return item
|
'Super the block.'
| @property
def super(self):
| if ((self._depth + 1) >= len(self._stack)):
return self._context.environment.undefined(('there is no parent block called %r.' % self.name), name='super')
return BlockReference(self.name, self._context, self._stack, (self._depth + 1))
|
'Cycles among the arguments with the current loop index.'
| def cycle(self, *args):
| if (not args):
raise TypeError('no items for cycling given')
return args[(self.index0 % len(args))]
|
'Regular callback function for undefined objects that raises an
`UndefinedError` on call.'
| @internalcode
def _fail_with_undefined_error(self, *args, **kwargs):
| if (self._undefined_hint is None):
if (self._undefined_obj is None):
hint = ('%r is undefined' % self._undefined_name)
elif (not isinstance(self._undefined_name, basestring)):
hint = ('%r object has no element %r' % (self._undefined_obj.__class__.__name__... |
'Convenience method that raises `exc` with the message, passed
line number or last line number as well as the current name and
filename.'
| def fail(self, msg, lineno=None, exc=TemplateSyntaxError):
| if (lineno is None):
lineno = self.stream.current.lineno
raise exc(msg, lineno, self.name, self.filename)
|
'Are we at the end of a tuple?'
| def is_tuple_end(self, extra_end_rules=None):
| if (self.stream.current.type in ('variable_end', 'block_end', 'rparen')):
return True
elif (extra_end_rules is not None):
return self.stream.current.test_any(extra_end_rules)
return False
|
'Return a new free identifier as :class:`~jinja2.nodes.InternalName`.'
| def free_identifier(self, lineno=None):
| self._last_identifier += 1
rv = object.__new__(nodes.InternalName)
nodes.Node.__init__(rv, ('fi%d' % self._last_identifier), lineno=lineno)
return rv
|
'Parse a single statement.'
| def parse_statement(self):
| token = self.stream.current
if (token.type != 'name'):
self.fail('tag name expected', token.lineno)
if (token.value in _statement_keywords):
return getattr(self, ('parse_' + self.stream.current.value))()
if (token.value == 'call'):
return self.parse_call_block()
if (tok... |
'Parse multiple statements into a list until one of the end tokens
is reached. This is used to parse the body of statements as it also
parses template data if appropriate. The parser checks first if the
current token is a colon and skips it if there is one. Then it checks
for the block end and parses until if one of... | def parse_statements(self, end_tokens, drop_needle=False):
| self.stream.skip_if('colon')
self.stream.expect('block_end')
result = self.subparse(end_tokens)
if drop_needle:
next(self.stream)
return result
|
'Parse an assign statement.'
| def parse_set(self):
| lineno = next(self.stream).lineno
target = self.parse_assign_target()
self.stream.expect('assign')
expr = self.parse_tuple()
return nodes.Assign(target, expr, lineno=lineno)
|
'Parse a for loop.'
| def parse_for(self):
| lineno = self.stream.expect('name:for').lineno
target = self.parse_assign_target(extra_end_rules=('name:in',))
self.stream.expect('name:in')
iter = self.parse_tuple(with_condexpr=False, extra_end_rules=('name:recursive',))
test = None
if self.stream.skip_if('name:if'):
test = self.parse_... |
'Parse an if construct.'
| def parse_if(self):
| node = result = nodes.If(lineno=self.stream.expect('name:if').lineno)
while 1:
node.test = self.parse_tuple(with_condexpr=False)
node.body = self.parse_statements(('name:elif', 'name:else', 'name:endif'))
token = next(self.stream)
if token.test('name:elif'):
new_node ... |
'Parse an assignment target. As Jinja2 allows assignments to
tuples, this function can parse all allowed assignment targets. Per
default assignments to tuples are parsed, that can be disable however
by setting `with_tuple` to `False`. If only assignments to names are
wanted `name_only` can be set to `True`. The `ex... | def parse_assign_target(self, with_tuple=True, name_only=False, extra_end_rules=None):
| if name_only:
token = self.stream.expect('name')
target = nodes.Name(token.value, 'store', lineno=token.lineno)
else:
if with_tuple:
target = self.parse_tuple(simplified=True, extra_end_rules=extra_end_rules)
else:
target = self.parse_primary(with_postfix=... |
'Parse an expression. Per default all expressions are parsed, if
the optional `with_condexpr` parameter is set to `False` conditional
expressions are not parsed.'
| def parse_expression(self, with_condexpr=True):
| if with_condexpr:
return self.parse_condexpr()
return self.parse_or()
|
'Works like `parse_expression` but if multiple expressions are
delimited by a comma a :class:`~jinja2.nodes.Tuple` node is created.
This method could also return a regular expression instead of a tuple
if no commas where found.
The default parsing mode is a full tuple. If `simplified` is `True`
only names and literals... | def parse_tuple(self, simplified=False, with_condexpr=True, extra_end_rules=None):
| lineno = self.stream.current.lineno
if simplified:
parse = (lambda : self.parse_primary(with_postfix=False))
elif with_condexpr:
parse = self.parse_expression
else:
parse = (lambda : self.parse_expression(with_condexpr=False))
args = []
is_tuple = False
while 1:
... |
'Parse the whole template into a `Template` node.'
| def parse(self):
| result = nodes.Template(self.subparse(), lineno=1)
result.set_environment(self.environment)
return result
|
'Return the visitor function for this node or `None` if no visitor
exists for this node. In that case the generic visit function is
used instead.'
| def get_visitor(self, node):
| method = ('visit_' + node.__class__.__name__)
return getattr(self, method, None)
|
'Visit a node.'
| def visit(self, node, *args, **kwargs):
| f = self.get_visitor(node)
if (f is not None):
return f(node, *args, **kwargs)
return self.generic_visit(node, *args, **kwargs)
|
'Called if no explicit visitor function exists for a node.'
| def generic_visit(self, node, *args, **kwargs):
| for node in node.iter_child_nodes():
self.visit(node, *args, **kwargs)
|
'As transformers may return lists in some places this method
can be used to enforce a list as return value.'
| def visit_list(self, node, *args, **kwargs):
| rv = self.visit(node, *args, **kwargs)
if (not isinstance(rv, list)):
rv = [rv]
return rv
|
'The sandboxed environment will call this method to check if the
attribute of an object is safe to access. Per default all attributes
starting with an underscore are considered private as well as the
special attributes of internal python objects as returned by the
:func:`is_internal_attribute` function.'
| def is_safe_attribute(self, obj, attr, value):
| return (not (attr.startswith('_') or is_internal_attribute(obj, attr)))
|
'Check if an object is safely callable. Per default a function is
considered safe unless the `unsafe_callable` attribute exists and is
True. Override this method to alter the behavior, but this won\'t
affect the `unsafe` decorator from this module.'
| def is_safe_callable(self, obj):
| return (not (getattr(obj, 'unsafe_callable', False) or getattr(obj, 'alters_data', False)))
|
'Subscribe an object from sandboxed code.'
| def getitem(self, obj, argument):
| try:
return obj[argument]
except (TypeError, LookupError):
if isinstance(argument, basestring):
try:
attr = str(argument)
except:
pass
else:
try:
value = getattr(obj, attr)
exc... |
'Subscribe an object from sandboxed code and prefer the
attribute. The attribute passed *must* be a bytestring.'
| def getattr(self, obj, attribute):
| try:
value = getattr(obj, attribute)
except AttributeError:
try:
return obj[attribute]
except (TypeError, LookupError):
pass
else:
if self.is_safe_attribute(obj, attribute, value):
return value
return self.unsafe_undefined(obj, attr... |
'Return an undefined object for unsafe attributes.'
| def unsafe_undefined(self, obj, attribute):
| return self.undefined(('access to attribute %r of %r object is unsafe.' % (attribute, obj.__class__.__name__)), name=attribute, obj=obj, exc=SecurityError)
|
'Call an object from sandboxed code.'
| def call(__self, __context, __obj, *args, **kwargs):
| if (not __self.is_safe_callable(__obj)):
raise SecurityError(('%r is not safely callable' % (__obj,)))
return __context.call(__obj, *args, **kwargs)
|
'Resets the bucket (unloads the bytecode).'
| def reset(self):
| self.code = None
|
'Loads bytecode from a file or file like object.'
| def load_bytecode(self, f):
| magic = f.read(len(bc_magic))
if (magic != bc_magic):
self.reset()
return
checksum = pickle.load(f)
if (self.checksum != checksum):
self.reset()
return
if isinstance(f, file):
self.code = marshal.load(f)
else:
self.code = marshal.loads(f.read())
|
'Dump the bytecode into the file or file like object passed.'
| def write_bytecode(self, f):
| if (self.code is None):
raise TypeError("can't write empty bucket")
f.write(bc_magic)
pickle.dump(self.checksum, f, 2)
if isinstance(f, file):
marshal.dump(self.code, f)
else:
f.write(marshal.dumps(self.code))
|
'Load bytecode from a string.'
| def bytecode_from_string(self, string):
| self.load_bytecode(StringIO(string))
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.