') diff --git a/genshi/template/astutil.py b/genshi/template/astutil.py --- a/genshi/template/astutil.py +++ b/genshi/template/astutil.py @@ -21,7 +21,7 @@ def parse(source, mode): return compile(source, '', mode, _ast.PyCF_ONLY_AST) -from genshi.compat import IS_PYTHON2 +from genshi.compat import IS_PYTHON2, isstring __docformat__ = 'restructuredtext en' @@ -103,32 +103,48 @@ self._new_line() return self.visit(node.body) + # Python < 3.4 # arguments = (expr* args, identifier? vararg, # identifier? kwarg, expr* defaults) + # + # Python >= 3.4 + # arguments = (arg* args, arg? vararg, arg* kwonlyargs, expr* kw_defaults, + # arg? kwarg, expr* defaults) def visit_arguments(self, node): - first = True - no_default_count = len(node.args) - len(node.defaults) - for i, arg in enumerate(node.args): - if not first: - self._write(', ') + def write_possible_comma(): + if _first[0]: + _first[0] = False else: - first = False - self.visit(arg) - if i >= no_default_count: - self._write('=') - self.visit(node.defaults[i - no_default_count]) - if getattr(node, 'vararg', None): - if not first: self._write(', ') + _first = [True] + + def write_args(args, defaults): + no_default_count = len(args) - len(defaults) + for i, arg in enumerate(args): + write_possible_comma() + self.visit(arg) + default_idx = i - no_default_count + if default_idx >= 0 and defaults[default_idx] is not None: + self._write('=') + self.visit(defaults[i - no_default_count]) + + write_args(node.args, node.defaults) + if getattr(node, 'vararg', None): + write_possible_comma() + self._write('*') + if isstring(node.vararg): + self._write(node.vararg) else: - first = False - self._write('*' + node.vararg) + self.visit(node.vararg) + if getattr(node, 'kwonlyargs', None): + write_args(node.kwonlyargs, node.kw_defaults) if getattr(node, 'kwarg', None): - if not first: - self._write(', ') + write_possible_comma() + self._write('**') + if isstring(node.kwarg): + self._write(node.kwarg) else: - first = False - self._write('**' + node.kwarg) + self.visit(node.kwarg) if not IS_PYTHON2: # In Python 3 arguments get a special node @@ -724,6 +740,17 @@ def visit_Name(self, node): self._write(node.id) + # NameConstant(singleton value) + def visit_NameConstant(self, node): + if node.value is None: + self._write('None') + elif node.value is True: + self._write('True') + elif node.value is False: + self._write('False') + else: + raise Exception("Unknown NameConstant %r" % (node.value,)) + # List(expr* elts, expr_context ctx) def visit_List(self, node): self._write('[') @@ -829,6 +856,7 @@ visit_Attribute = _clone visit_Subscript = _clone visit_Name = _clone + visit_NameConstant = _clone visit_List = _clone visit_Tuple = _clone diff --git a/genshi/template/eval.py b/genshi/template/eval.py --- a/genshi/template/eval.py +++ b/genshi/template/eval.py @@ -24,7 +24,8 @@ from genshi.template.base import TemplateRuntimeError from genshi.util import flatten -from genshi.compat import get_code_params, build_code_chunk, IS_PYTHON2 +from genshi.compat import get_code_params, build_code_chunk, isstring, \ + IS_PYTHON2 __all__ = ['Code', 'Expression', 'Suite', 'LenientLookup', 'StrictLookup', 'Undefined', 'UndefinedError'] @@ -495,28 +496,34 @@ def __init__(self): self.locals = [CONSTANTS] + def _process(self, names, node): + if not IS_PYTHON2 and isinstance(node, _ast.arg): + names.add(node.arg) + elif isstring(node): + names.add(node) + elif isinstance(node, _ast.Name): + names.add(node.id) + elif isinstance(node, _ast.alias): + names.add(node.asname or node.name) + elif isinstance(node, _ast.Tuple): + for elt in node.elts: + self._process(names, elt) + def _extract_names(self, node): names = set() - def _process(node): - if not IS_PYTHON2 and isinstance(node, _ast.arg): - names.add(node.arg) - if isinstance(node, _ast.Name): - names.add(node.id) - elif isinstance(node, _ast.alias): - names.add(node.asname or node.name) - elif isinstance(node, _ast.Tuple): - for elt in node.elts: - _process(elt) if hasattr(node, 'args'): for arg in node.args: - _process(arg) + self._process(names, arg) + if hasattr(node, 'kwonlyargs'): + for arg in node.kwonlyargs: + self._process(names, arg) if hasattr(node, 'vararg'): - names.add(node.vararg) + self._process(names, node.vararg) if hasattr(node, 'kwarg'): - names.add(node.kwarg) + self._process(names, node.kwarg) elif hasattr(node, 'names'): for elt in node.names: - _process(elt) + self._process(names, elt) return names def visit_Str(self, node): diff --git a/genshi/template/tests/eval.py b/genshi/template/tests/eval.py --- a/genshi/template/tests/eval.py +++ b/genshi/template/tests/eval.py @@ -590,6 +590,29 @@ suite.execute(data) self.assertEqual(['bardef', 'fooabc'], sorted(data['x'])) + if not IS_PYTHON2: + def test_def_kwonlyarg(self): + suite = Suite(""" +def kwonly(*args, k): + return k +x = kwonly(k="foo") +""") + data = {} + suite.execute(data) + self.assertEqual("foo", data['x']) + + def test_def_kwonlyarg_with_default(self): + suite = Suite(""" +def kwonly(*args, k="bar"): + return k +x = kwonly(k="foo") +y = kwonly() +""") + data = {} + suite.execute(data) + self.assertEqual("foo", data['x']) + self.assertEqual("bar", data['y']) + def test_def_nested(self): suite = Suite(""" def doit(): diff --git a/run_benchmarks.sh b/run_benchmarks.sh new file mode 100644 --- /dev/null +++ b/run_benchmarks.sh @@ -0,0 +1,31 @@ +#!/bin/sh +# +# 1. Run the tests with `tox` (this will set up all the tox envs). +# 2. ./run_benchmarks.sh | tee results-.out + +NAME="$1" +PYTHON="./.tox/$NAME/bin/python" +BENCH_DIR="bench_build/$1" +BENCH_BIN_DIR="$BENCH_DIR/bin" +mkdir -p "bench_build" + +rm -rf "$BENCH_DIR" +cp -R "examples/bench" "$BENCH_DIR" + +case "$NAME" in + py32|py33) + 2to3 -w --no-diffs "$BENCH_DIR" + ;; +esac + +echo "-- basic --" +"$PYTHON" "$BENCH_DIR/basic.py" +echo + +echo "-- bigtable --" +"$PYTHON" "$BENCH_DIR/bigtable.py" +echo + +echo "-- xpath --" +"$PYTHON" "$BENCH_DIR/xpath.py" +echo diff --git a/setup.py b/setup.py --- a/setup.py +++ b/setup.py @@ -65,9 +65,13 @@ if Feature: + # Optional C extension module for speeding up Genshi: + # Not activated by default on: + # - PyPy (where it harms performance) + # - CPython >= 3.3 (the new Unicode C API is not supported yet) speedups = Feature( "optional C speed-enhancements", - standard = not is_pypy, + standard = not is_pypy and sys.version_info < (3, 3), ext_modules = [ Extension('genshi._speedups', ['genshi/_speedups.c']), ],