Mailman 3 February 2016 - Python-checkins

benchmarks: Issue #25774: Add raw mode to perf.py.
by zach.ware 03 Feb '16

03 Feb '16

https://hg.python.org/benchmarks/rev/9923b81a1d34 changeset: 239:9923b81a1d34 user: Zachary Ware <zachary.ware(a)gmail.com> date: Wed Feb 03 14:19:18 2016 -0600 summary: Issue #25774: Add raw mode to perf.py. Raw mode runs the benchmark(s) on a single interpreter and returns the result from main() as a dict. files: perf.py | 75 ++++++++++++++++++++++++++++++++++++++++++-- 1 files changed, 71 insertions(+), 4 deletions(-) diff --git a/perf.py b/perf.py --- a/perf.py +++ b/perf.py @@ -818,6 +818,8 @@ try: changed_data = benchmark_function(changed_python, options, *args, **kwargs) + if options.raw: + return FormatRawData(changed_data, options) base_data = benchmark_function(base_python, options, *args, **kwargs) except subprocess.CalledProcessError as e: @@ -1113,6 +1115,33 @@ std_changed, delta_std, significant, timeline_link) +class RawBenchmarkResult(dict): + + def __init__(self, average, min=None, max=None, std_dev=None): + self['average'] = average + if min is not None: + self['min'] = min + if max is not None: + self['max'] = max + if std_dev is not None: + self['std_dev'] = std_dev + + def __str__(self): + return '\n'.join('%s: %s' % i for i in sorted(self.items())) + + +def FormatRawData(bm_data, options): + # XXX implement track_memory handling? + times = sorted(bm_data.runtimes) + average = avg(times) + mn = mx = std = None + if len(times) > 1: + mn = times[0] + mx = times[-1] + std = SampleStdDev(times) + return RawBenchmarkResult(average, mn, mx, std) + + def CompareBenchmarkData(base_data, exp_data, options): """Compare performance and memory usage. @@ -1665,6 +1694,8 @@ try: changed_data = MeasureSpitfire(changed_python, options, spitfire_env, extra_args) + if options.raw: + return FormatRawData(changed_data, options) base_data = MeasureSpitfire(base_python, options, spitfire_env, extra_args) except subprocess.CalledProcessError as e: @@ -2069,6 +2100,8 @@ opts = [] changed_data = MeasureStartup(changed_python, opts, num_loops, options.track_memory, options.inherit_env) + if options.raw: + return FormatRawData(changed_data, options) base_data = MeasureStartup(base_python, opts, num_loops, options.track_memory, options.inherit_env) @@ -2086,6 +2119,8 @@ opts = ["-S"] changed_data = MeasureStartup(changed_python, opts, num_loops, options.track_memory, options.inherit_env) + if options.raw: + return FormatRawData(changed_data, options) base_data = MeasureStartup(base_python, opts, num_loops, options.track_memory, options.inherit_env) @@ -2370,6 +2405,8 @@ SLOW_BENCHMARKS = ["hexiom2"] +NON_RAW_BENCHMARKS = ["pybench"] + def _ExpandBenchmarkName(bm_name, bench_groups): """Recursively expand name benchmark names. @@ -2389,7 +2426,7 @@ yield bm_name -def ParseBenchmarksOption(benchmarks_opt, bench_groups, fast=False): +def ParseBenchmarksOption(benchmarks_opt, bench_groups, fast=False, raw=False): """Parses and verifies the --benchmarks option. Args: @@ -2431,6 +2468,12 @@ logging.info("Skipping slow benchmarks (%s) in fast mode", ', '.join(sorted(to_skip))) should_run = should_run - to_skip + if raw: + to_skip = should_run & set(NON_RAW_BENCHMARKS) + if to_skip: + logging.info("Skipping raw-incompatible benchmarks (%s) " + "in raw mode", ', '.join(sorted(to_skip))) + should_run = should_run - to_skip return should_run @@ -2581,6 +2624,10 @@ " Unladen Swallow binaries. This is useful for" " examining many benchmarks for optimization" " effects.")) + parser.add_option("--raw", action="store_true", + help="Run the benchmarks on only one interpreter and " + "return the timing information for each benchmark. " + "Provide only baseline_python, not changed_python.") parser.add_option("--affinity", metavar="CPU_LIST", default=None, help=("Specify CPU affinity for benchmark runs. This " "way, benchmarks can be forced to run on a given " @@ -2589,9 +2636,13 @@ options, args = parser.parse_args(argv) - if len(args) != 2: + expected = 1 if options.raw else 2 + if len(args) != expected: parser.error("incorrect number of arguments") - base, changed = args + if expected == 1: + base = changed = args[0] + else: + base, changed = args options.base_binary = base options.changed_binary = changed @@ -2601,6 +2652,16 @@ options.experiment_label = options.changed_binary base_args, changed_args = ParsePythonArgsOption(options.args) + if options.raw: + if base_args != changed_args: + parser.error('provide args for only one interpreter in raw mode') + if options.track_memory: + # XXX this might be worth fixing someday? + parser.error('raw mode is not compatible with memory tracking') + if options.diff_instrumentation: + parser.error('raw mode is not compatible with instrumentation') + if options.csv: + parser.error('raw mode does not support csv output') base_cmd_prefix = [base] + base_args changed_cmd_prefix = [changed] + changed_args @@ -2633,7 +2694,7 @@ info("Automatically selected timer: %s", options.timer) should_run = ParseBenchmarksOption(options.benchmarks, bench_groups, - options.fast) + options.fast, options.raw) should_run = FilterBenchmarks(should_run, bench_funcs, base_cmd_prefix, changed_cmd_prefix) @@ -2653,6 +2714,12 @@ print("Report on %s" % " ".join(platform.uname())) if multiprocessing: print("Total CPU cores:", multiprocessing.cpu_count()) + if options.raw: + for name, result in results: + print() + print("###", name, "###") + print(result) + return dict(results) hidden = [] if not options.verbose: shown = [] -- Repository URL: https://hg.python.org/benchmarks

1 0

UGLY Benchmark Results for Python 2.7 2016-02-03
by lp_benchmark_robot＠intel.com 03 Feb '16

03 Feb '16

Results for project Python 2.7, build date 2016-02-03 03:57:26 +0000 commit: 628ce2975e29 previous commit: 6f7b2b7a029a revision date: 2016-02-02 16:45:59 +0000 environment: Haswell-EP cpu: Intel(R) Xeon(R) CPU E5-2699 v3 @ 2.30GHz 2x18 cores, stepping 2, LLC 45 MB mem: 128 GB os: CentOS 7.1 kernel: Linux 3.10.0-229.4.2.el7.x86_64 Baseline results were generated using release v2.7.10, with hash 15c95b7d81dc from 2015-05-23 16:02:14+00:00 ---------------------------------------------------------------------------------- benchmark relative change since change since current rev run std_dev* last run baseline with PGO ---------------------------------------------------------------------------------- :-) django_v2 0.14% 0.50% 2.89% 4.28% :-) pybench 0.12% -0.38% 5.85% 5.30% :-( regex_v8 0.55% -0.04% -2.45% 11.14% :-) nbody 0.17% -0.06% 8.05% -0.17% :-) json_dump_v2 0.23% -1.05% 3.66% 9.83% :-) normal_startup 1.25% 4.47% -0.28% -2.53% :-| ssbench 0.22% 0.54% 1.27% 1.83% ---------------------------------------------------------------------------------- * Relative Standard Deviation (Standard Deviation/Average) If this is not displayed properly please visit our results page here: http://languagesperformance.intel.com/ugly-benchmark-results-for-python-2-7… Note: Benchmark results for ssbench are measured in requests/second while all other are measured in seconds. Subject Label Legend: Attributes are determined based on the performance evolution of the workloads compared to the previous measurement iteration. NEUTRAL: performance did not change by more than 1% for any workload GOOD: performance improved by more than 1% for at least one workload and there is no regression greater than 1% BAD: performance dropped by more than 1% for at least one workload and there is no improvement greater than 1% UGLY: performance improved by more than 1% for at least one workload and also dropped by more than 1% for at least one workload Our lab does a nightly source pull and build of the Python project and measures performance changes against the previous stable version and the previous nightly measurement. This is provided as a service to the community so that quality issues with current hardware can be identified quickly. Intel technologies' features and benefits depend on system configuration and may require enabled hardware, software or service activation. Performance varies depending on system configuration.

1 0

UGLY Benchmark Results for Python Default 2016-02-03
by lp_benchmark_robot＠intel.com 03 Feb '16

03 Feb '16

Results for project Python default, build date 2016-02-03 03:06:10 +0000 commit: 5873cfb42ebe previous commit: 3b211ee66b82 revision date: 2016-02-02 23:04:56 +0000 environment: Haswell-EP cpu: Intel(R) Xeon(R) CPU E5-2699 v3 @ 2.30GHz 2x18 cores, stepping 2, LLC 45 MB mem: 128 GB os: CentOS 7.1 kernel: Linux 3.10.0-229.4.2.el7.x86_64 Baseline results were generated using release v3.4.3, with hash b4cbecbc0781 from 2015-02-25 12:15:33+00:00 ---------------------------------------------------------------------------------- benchmark relative change since change since current rev run std_dev* last run baseline with PGO ---------------------------------------------------------------------------------- :-) django_v2 0.32% -1.69% 8.32% 15.47% :-| pybench 0.10% 0.02% -1.15% 4.91% :-( regex_v8 2.74% -0.41% -3.70% 4.65% :-| nbody 0.86% -0.77% -0.32% 8.81% :-( json_dump_v2 0.18% -2.94% -4.55% 11.88% :-) normal_startup 1.14% 3.12% 3.49% 5.27% ---------------------------------------------------------------------------------- * Relative Standard Deviation (Standard Deviation/Average) If this is not displayed properly please visit our results page here: http://languagesperformance.intel.com/ugly-benchmark-results-for-python-def… Note: Benchmark results are measured in seconds. Subject Label Legend: Attributes are determined based on the performance evolution of the workloads compared to the previous measurement iteration. NEUTRAL: performance did not change by more than 1% for any workload GOOD: performance improved by more than 1% for at least one workload and there is no regression greater than 1% BAD: performance dropped by more than 1% for at least one workload and there is no improvement greater than 1% UGLY: performance improved by more than 1% for at least one workload and also dropped by more than 1% for at least one workload Our lab does a nightly source pull and build of the Python project and measures performance changes against the previous stable version and the previous nightly measurement. This is provided as a service to the community so that quality issues with current hardware can be identified quickly. Intel technologies' features and benefits depend on system configuration and may require enabled hardware, software or service activation. Performance varies depending on system configuration.

1 0

benchmarks: Add --affinity command line option
by victor.stinner 03 Feb '16

03 Feb '16

https://hg.python.org/benchmarks/rev/a97acad3bbf7 changeset: 238:a97acad3bbf7 user: Victor Stinner <victor.stinner(a)gmail.com> date: Wed Feb 03 15:20:02 2016 +0100 summary: Add --affinity command line option If used, run the benchmark using taskset to pin the process to a set of CPU cores to reduce context switching. See taskset manual page for more information. Patch written by Florin Papa. files: perf.py | 40 ++++++++++++++++++++++++++++++++++++++++ 1 files changed, 40 insertions(+), 0 deletions(-) diff --git a/perf.py b/perf.py --- a/perf.py +++ b/perf.py @@ -88,6 +88,30 @@ info = logging.info +def check_taskset(): + """Check the taskset command is available. + + Taskset specifies CPU affinity for a given workload, meaning that we can + run the benchmarks on a given core to minimize run to run variation. + + Return None on success. Return an error message on error. + """ + with open(os.devnull, "wb") as dev_null: + # Try to pin a temporary Python process to CPU #0 + command = ["taskset", "--cpu-list", "0", + sys.executable, "-c", "pass"] + try: + exitcode = subprocess.call(command, + stdout=dev_null, stderr=dev_null) + except OSError as exc: + return ("Command taskset not found: %s" % exc) + + if exitcode != 0: + return ("Command taskset failed with exit code %s" % exitcode) + + return None + + def interpreter_version(python, _cache={}): """Return the interpreter version for the given Python interpreter. *python* is the base command (as a list) to execute the interpreter. @@ -2557,6 +2581,11 @@ " Unladen Swallow binaries. This is useful for" " examining many benchmarks for optimization" " effects.")) + parser.add_option("--affinity", metavar="CPU_LIST", default=None, + help=("Specify CPU affinity for benchmark runs. This " + "way, benchmarks can be forced to run on a given " + "CPU to minimize run to run variation. This uses " + "the taskset command.")) options, args = parser.parse_args(argv) @@ -2575,6 +2604,17 @@ base_cmd_prefix = [base] + base_args changed_cmd_prefix = [changed] + changed_args + if options.affinity: + err_msg = check_taskset() + if err_msg: + print("ERROR: Option --affinity not available. %s" % err_msg, + file=sys.stderr) + sys.exit(1) + + taskset_prefix = ["taskset", "--cpu-list", options.affinity] + base_cmd_prefix = taskset_prefix + base_cmd_prefix + changed_cmd_prefix = taskset_prefix + changed_cmd_prefix + logging.basicConfig(level=logging.INFO) if options.track_memory: -- Repository URL: https://hg.python.org/benchmarks

1 0

Daily reference leaks (5873cfb42ebe): sum=4
by solipsis＠pitrou.net 03 Feb '16

03 Feb '16

results for 5873cfb42ebe on branch "default" -------------------------------------------- test_functools leaked [0, 2, 2] memory blocks, sum=4 Command line was: ['./python', '-m', 'test.regrtest', '-uall', '-R', '3:3:/home/psf-users/antoine/refleaks/reflogT_C_La', '--timeout', '7200']

1 0

cpython (merge 3.5 -> default): Merge with 3.5
by zach.ware 02 Feb '16

02 Feb '16

https://hg.python.org/cpython/rev/5873cfb42ebe changeset: 100151:5873cfb42ebe parent: 100148:33109176538d parent: 100150:e4eb2a8fdb7c user: Zachary Ware <zachary.ware(a)gmail.com> date: Tue Feb 02 17:04:56 2016 -0600 summary: Merge with 3.5 files: Doc/library/typing.rst | 2 +- 1 files changed, 1 insertions(+), 1 deletions(-) diff --git a/Doc/library/typing.rst b/Doc/library/typing.rst --- a/Doc/library/typing.rst +++ b/Doc/library/typing.rst @@ -20,7 +20,7 @@ def greeting(name: str) -> str: return 'Hello ' + name -In the function ``greeting``, the argument ``name`` is expected to by of type +In the function ``greeting``, the argument ``name`` is expected to be of type :class:`str` and the return type :class:`str`. Subtypes are accepted as arguments. -- Repository URL: https://hg.python.org/cpython

1 0

cpython (3.5): Fix typo.
by zach.ware 02 Feb '16

02 Feb '16

https://hg.python.org/cpython/rev/e4eb2a8fdb7c changeset: 100150:e4eb2a8fdb7c branch: 3.5 parent: 100147:542b5744ddc3 user: Zachary Ware <zachary.ware(a)gmail.com> date: Tue Feb 02 17:04:41 2016 -0600 summary: Fix typo. Reported by Jon Tetlak on docs@ files: Doc/library/typing.rst | 2 +- 1 files changed, 1 insertions(+), 1 deletions(-) diff --git a/Doc/library/typing.rst b/Doc/library/typing.rst --- a/Doc/library/typing.rst +++ b/Doc/library/typing.rst @@ -20,7 +20,7 @@ def greeting(name: str) -> str: return 'Hello ' + name -In the function ``greeting``, the argument ``name`` is expected to by of type +In the function ``greeting``, the argument ``name`` is expected to be of type :class:`str` and the return type :class:`str`. Subtypes are accepted as arguments. -- Repository URL: https://hg.python.org/cpython

1 0

cpython (merge 3.5 -> default): Issue #25945: Fixed bugs in functools.partial.
by serhiy.storchaka 02 Feb '16

02 Feb '16

https://hg.python.org/cpython/rev/33109176538d changeset: 100148:33109176538d parent: 100146:03708c680eca parent: 100147:542b5744ddc3 user: Serhiy Storchaka <storchaka(a)gmail.com> date: Tue Feb 02 18:45:47 2016 +0200 summary: Issue #25945: Fixed bugs in functools.partial. Fixed a crash when unpickle the functools.partial object with wrong state. Fixed a leak in failed functools.partial constructor. "args" and "keywords" attributes of functools.partial have now always types tuple and dict correspondingly. files: Lib/test/test_functools.py | 93 ++++++++++++++++- Misc/NEWS | 5 + Modules/_functoolsmodule.c | 128 +++++++++++++----------- 3 files changed, 160 insertions(+), 66 deletions(-) diff --git a/Lib/test/test_functools.py b/Lib/test/test_functools.py --- a/Lib/test/test_functools.py +++ b/Lib/test/test_functools.py @@ -30,6 +30,16 @@ """ return the signature of a partial object """ return (part.func, part.args, part.keywords, part.__dict__) +class MyTuple(tuple): + pass + +class BadTuple(tuple): + def __add__(self, other): + return list(self) + list(other) + +class MyDict(dict): + pass + class TestPartial: @@ -208,11 +218,84 @@ for kwargs_repr in kwargs_reprs]) def test_pickle(self): - f = self.partial(signature, 'asdf', bar=True) - f.add_something_to__dict__ = True + f = self.partial(signature, ['asdf'], bar=[True]) + f.attr = [] for proto in range(pickle.HIGHEST_PROTOCOL + 1): f_copy = pickle.loads(pickle.dumps(f, proto)) - self.assertEqual(signature(f), signature(f_copy)) + self.assertEqual(signature(f_copy), signature(f)) + + def test_copy(self): + f = self.partial(signature, ['asdf'], bar=[True]) + f.attr = [] + f_copy = copy.copy(f) + self.assertEqual(signature(f_copy), signature(f)) + self.assertIs(f_copy.attr, f.attr) + self.assertIs(f_copy.args, f.args) + self.assertIs(f_copy.keywords, f.keywords) + + def test_deepcopy(self): + f = self.partial(signature, ['asdf'], bar=[True]) + f.attr = [] + f_copy = copy.deepcopy(f) + self.assertEqual(signature(f_copy), signature(f)) + self.assertIsNot(f_copy.attr, f.attr) + self.assertIsNot(f_copy.args, f.args) + self.assertIsNot(f_copy.args[0], f.args[0]) + self.assertIsNot(f_copy.keywords, f.keywords) + self.assertIsNot(f_copy.keywords['bar'], f.keywords['bar']) + + def test_setstate(self): + f = self.partial(signature) + f.__setstate__((capture, (1,), dict(a=10), dict(attr=[]))) + self.assertEqual(signature(f), + (capture, (1,), dict(a=10), dict(attr=[]))) + self.assertEqual(f(2, b=20), ((1, 2), {'a': 10, 'b': 20})) + + f.__setstate__((capture, (1,), dict(a=10), None)) + self.assertEqual(signature(f), (capture, (1,), dict(a=10), {})) + self.assertEqual(f(2, b=20), ((1, 2), {'a': 10, 'b': 20})) + + f.__setstate__((capture, (1,), None, None)) + #self.assertEqual(signature(f), (capture, (1,), {}, {})) + self.assertEqual(f(2, b=20), ((1, 2), {'b': 20})) + self.assertEqual(f(2), ((1, 2), {})) + self.assertEqual(f(), ((1,), {})) + + f.__setstate__((capture, (), {}, None)) + self.assertEqual(signature(f), (capture, (), {}, {})) + self.assertEqual(f(2, b=20), ((2,), {'b': 20})) + self.assertEqual(f(2), ((2,), {})) + self.assertEqual(f(), ((), {})) + + def test_setstate_errors(self): + f = self.partial(signature) + self.assertRaises(TypeError, f.__setstate__, (capture, (), {})) + self.assertRaises(TypeError, f.__setstate__, (capture, (), {}, {}, None)) + self.assertRaises(TypeError, f.__setstate__, [capture, (), {}, None]) + self.assertRaises(TypeError, f.__setstate__, (None, (), {}, None)) + self.assertRaises(TypeError, f.__setstate__, (capture, None, {}, None)) + self.assertRaises(TypeError, f.__setstate__, (capture, [], {}, None)) + self.assertRaises(TypeError, f.__setstate__, (capture, (), [], None)) + + def test_setstate_subclasses(self): + f = self.partial(signature) + f.__setstate__((capture, MyTuple((1,)), MyDict(a=10), None)) + s = signature(f) + self.assertEqual(s, (capture, (1,), dict(a=10), {})) + self.assertIs(type(s[1]), tuple) + self.assertIs(type(s[2]), dict) + r = f() + self.assertEqual(r, ((1,), {'a': 10})) + self.assertIs(type(r[0]), tuple) + self.assertIs(type(r[1]), dict) + + f.__setstate__((capture, BadTuple((1,)), {}, None)) + s = signature(f) + self.assertEqual(s, (capture, (1,), {}, {})) + self.assertIs(type(s[1]), tuple) + r = f(2) + self.assertEqual(r, ((1, 2), {})) + self.assertIs(type(r[0]), tuple) # Issue 6083: Reference counting bug def test_setstate_refcount(self): @@ -229,9 +312,7 @@ raise IndexError f = self.partial(object) - self.assertRaisesRegex(SystemError, - "new style getargs format but argument is not a tuple", - f.__setstate__, BadSequence()) + self.assertRaises(TypeError, f.__setstate__, BadSequence()) class TestPartialPy(TestPartial, unittest.TestCase): diff --git a/Misc/NEWS b/Misc/NEWS --- a/Misc/NEWS +++ b/Misc/NEWS @@ -166,6 +166,11 @@ Library ------- +- Issue #25945: Fixed a crash when unpickle the functools.partial object with + wrong state. Fixed a leak in failed functools.partial constructor. + "args" and "keywords" attributes of functools.partial have now always types + tuple and dict correspondingly. + - Issue #26202: copy.deepcopy() now correctly copies range() objects with non-atomic attributes. diff --git a/Modules/_functoolsmodule.c b/Modules/_functoolsmodule.c --- a/Modules/_functoolsmodule.c +++ b/Modules/_functoolsmodule.c @@ -34,7 +34,7 @@ return NULL; } - pargs = pkw = Py_None; + pargs = pkw = NULL; func = PyTuple_GET_ITEM(args, 0); if (Py_TYPE(func) == &partial_type && type == &partial_type) { partialobject *part = (partialobject *)func; @@ -42,6 +42,8 @@ pargs = part->args; pkw = part->kw; func = part->fn; + assert(PyTuple_Check(pargs)); + assert(PyDict_Check(pkw)); } } if (!PyCallable_Check(func)) { @@ -60,12 +62,10 @@ nargs = PyTuple_GetSlice(args, 1, PY_SSIZE_T_MAX); if (nargs == NULL) { - pto->args = NULL; - pto->kw = NULL; Py_DECREF(pto); return NULL; } - if (pargs == Py_None || PyTuple_GET_SIZE(pargs) == 0) { + if (pargs == NULL || PyTuple_GET_SIZE(pargs) == 0) { pto->args = nargs; Py_INCREF(nargs); } @@ -76,47 +76,36 @@ else { pto->args = PySequence_Concat(pargs, nargs); if (pto->args == NULL) { - pto->kw = NULL; + Py_DECREF(nargs); Py_DECREF(pto); return NULL; } + assert(PyTuple_Check(pto->args)); } Py_DECREF(nargs); - if (kw != NULL) { - if (pkw == Py_None) { - pto->kw = PyDict_Copy(kw); + if (pkw == NULL || PyDict_Size(pkw) == 0) { + if (kw == NULL) { + pto->kw = PyDict_New(); } else { - pto->kw = PyDict_Copy(pkw); - if (pto->kw != NULL) { - if (PyDict_Merge(pto->kw, kw, 1) != 0) { - Py_DECREF(pto); - return NULL; - } - } - } - if (pto->kw == NULL) { - Py_DECREF(pto); - return NULL; + Py_INCREF(kw); + pto->kw = kw; } } else { - if (pkw == Py_None) { - pto->kw = PyDict_New(); - if (pto->kw == NULL) { + pto->kw = PyDict_Copy(pkw); + if (kw != NULL && pto->kw != NULL) { + if (PyDict_Merge(pto->kw, kw, 1) != 0) { Py_DECREF(pto); return NULL; } } - else { - pto->kw = pkw; - Py_INCREF(pkw); - } } - - pto->weakreflist = NULL; - pto->dict = NULL; + if (pto->kw == NULL) { + Py_DECREF(pto); + return NULL; + } return (PyObject *)pto; } @@ -138,11 +127,11 @@ partial_call(partialobject *pto, PyObject *args, PyObject *kw) { PyObject *ret; - PyObject *argappl = NULL, *kwappl = NULL; + PyObject *argappl, *kwappl; assert (PyCallable_Check(pto->fn)); assert (PyTuple_Check(pto->args)); - assert (pto->kw == Py_None || PyDict_Check(pto->kw)); + assert (PyDict_Check(pto->kw)); if (PyTuple_GET_SIZE(pto->args) == 0) { argappl = args; @@ -154,11 +143,12 @@ argappl = PySequence_Concat(pto->args, args); if (argappl == NULL) return NULL; + assert(PyTuple_Check(argappl)); } - if (pto->kw == Py_None) { + if (PyDict_Size(pto->kw) == 0) { kwappl = kw; - Py_XINCREF(kw); + Py_XINCREF(kwappl); } else { kwappl = PyDict_Copy(pto->kw); if (kwappl == NULL) { @@ -217,6 +207,7 @@ PyObject *arglist; PyObject *tmp; Py_ssize_t i, n; + PyObject *key, *value; arglist = PyUnicode_FromString(""); if (arglist == NULL) { @@ -234,17 +225,14 @@ arglist = tmp; } /* Pack keyword arguments */ - assert (pto->kw == Py_None || PyDict_Check(pto->kw)); - if (pto->kw != Py_None) { - PyObject *key, *value; - for (i = 0; PyDict_Next(pto->kw, &i, &key, &value);) { - tmp = PyUnicode_FromFormat("%U, %U=%R", arglist, - key, value); - Py_DECREF(arglist); - if (tmp == NULL) - return NULL; - arglist = tmp; - } + assert (PyDict_Check(pto->kw)); + for (i = 0; PyDict_Next(pto->kw, &i, &key, &value);) { + tmp = PyUnicode_FromFormat("%U, %U=%R", arglist, + key, value); + Py_DECREF(arglist); + if (tmp == NULL) + return NULL; + arglist = tmp; } result = PyUnicode_FromFormat("%s(%R%U)", Py_TYPE(pto)->tp_name, pto->fn, arglist); @@ -271,25 +259,45 @@ partial_setstate(partialobject *pto, PyObject *state) { PyObject *fn, *fnargs, *kw, *dict; - if (!PyArg_ParseTuple(state, "OOOO", - &fn, &fnargs, &kw, &dict)) + + if (!PyTuple_Check(state) || + !PyArg_ParseTuple(state, "OOOO", &fn, &fnargs, &kw, &dict) || + !PyCallable_Check(fn) || + !PyTuple_Check(fnargs) || + (kw != Py_None && !PyDict_Check(kw))) + { + PyErr_SetString(PyExc_TypeError, "invalid partial state"); return NULL; - Py_XDECREF(pto->fn); - Py_XDECREF(pto->args); - Py_XDECREF(pto->kw); - Py_XDECREF(pto->dict); - pto->fn = fn; - pto->args = fnargs; - pto->kw = kw; - if (dict != Py_None) { - pto->dict = dict; - Py_INCREF(dict); - } else { - pto->dict = NULL; } + + if(!PyTuple_CheckExact(fnargs)) + fnargs = PySequence_Tuple(fnargs); + else + Py_INCREF(fnargs); + if (fnargs == NULL) + return NULL; + + if (kw == Py_None) + kw = PyDict_New(); + else if(!PyDict_CheckExact(kw)) + kw = PyDict_Copy(kw); + else + Py_INCREF(kw); + if (kw == NULL) { + Py_DECREF(fnargs); + return NULL; + } + Py_INCREF(fn); - Py_INCREF(fnargs); - Py_INCREF(kw); + if (dict == Py_None) + dict = NULL; + else + Py_INCREF(dict); + + Py_SETREF(pto->fn, fn); + Py_SETREF(pto->args, fnargs); + Py_SETREF(pto->kw, kw); + Py_SETREF(pto->dict, dict); Py_RETURN_NONE; } -- Repository URL: https://hg.python.org/cpython

1 0

cpython (3.5): Issue #25945: Fixed bugs in functools.partial.
by serhiy.storchaka 02 Feb '16

02 Feb '16

https://hg.python.org/cpython/rev/542b5744ddc3 changeset: 100147:542b5744ddc3 branch: 3.5 parent: 100145:950e0bfe94ae user: Serhiy Storchaka <storchaka(a)gmail.com> date: Tue Feb 02 18:45:17 2016 +0200 summary: Issue #25945: Fixed bugs in functools.partial. Fixed a crash when unpickle the functools.partial object with wrong state. Fixed a leak in failed functools.partial constructor. "args" and "keywords" attributes of functools.partial have now always types tuple and dict correspondingly. files: Lib/test/test_functools.py | 93 ++++++++++++++++- Misc/NEWS | 5 + Modules/_functoolsmodule.c | 128 +++++++++++++----------- 3 files changed, 160 insertions(+), 66 deletions(-) diff --git a/Lib/test/test_functools.py b/Lib/test/test_functools.py --- a/Lib/test/test_functools.py +++ b/Lib/test/test_functools.py @@ -30,6 +30,16 @@ """ return the signature of a partial object """ return (part.func, part.args, part.keywords, part.__dict__) +class MyTuple(tuple): + pass + +class BadTuple(tuple): + def __add__(self, other): + return list(self) + list(other) + +class MyDict(dict): + pass + class TestPartial: @@ -208,11 +218,84 @@ for kwargs_repr in kwargs_reprs]) def test_pickle(self): - f = self.partial(signature, 'asdf', bar=True) - f.add_something_to__dict__ = True + f = self.partial(signature, ['asdf'], bar=[True]) + f.attr = [] for proto in range(pickle.HIGHEST_PROTOCOL + 1): f_copy = pickle.loads(pickle.dumps(f, proto)) - self.assertEqual(signature(f), signature(f_copy)) + self.assertEqual(signature(f_copy), signature(f)) + + def test_copy(self): + f = self.partial(signature, ['asdf'], bar=[True]) + f.attr = [] + f_copy = copy.copy(f) + self.assertEqual(signature(f_copy), signature(f)) + self.assertIs(f_copy.attr, f.attr) + self.assertIs(f_copy.args, f.args) + self.assertIs(f_copy.keywords, f.keywords) + + def test_deepcopy(self): + f = self.partial(signature, ['asdf'], bar=[True]) + f.attr = [] + f_copy = copy.deepcopy(f) + self.assertEqual(signature(f_copy), signature(f)) + self.assertIsNot(f_copy.attr, f.attr) + self.assertIsNot(f_copy.args, f.args) + self.assertIsNot(f_copy.args[0], f.args[0]) + self.assertIsNot(f_copy.keywords, f.keywords) + self.assertIsNot(f_copy.keywords['bar'], f.keywords['bar']) + + def test_setstate(self): + f = self.partial(signature) + f.__setstate__((capture, (1,), dict(a=10), dict(attr=[]))) + self.assertEqual(signature(f), + (capture, (1,), dict(a=10), dict(attr=[]))) + self.assertEqual(f(2, b=20), ((1, 2), {'a': 10, 'b': 20})) + + f.__setstate__((capture, (1,), dict(a=10), None)) + self.assertEqual(signature(f), (capture, (1,), dict(a=10), {})) + self.assertEqual(f(2, b=20), ((1, 2), {'a': 10, 'b': 20})) + + f.__setstate__((capture, (1,), None, None)) + #self.assertEqual(signature(f), (capture, (1,), {}, {})) + self.assertEqual(f(2, b=20), ((1, 2), {'b': 20})) + self.assertEqual(f(2), ((1, 2), {})) + self.assertEqual(f(), ((1,), {})) + + f.__setstate__((capture, (), {}, None)) + self.assertEqual(signature(f), (capture, (), {}, {})) + self.assertEqual(f(2, b=20), ((2,), {'b': 20})) + self.assertEqual(f(2), ((2,), {})) + self.assertEqual(f(), ((), {})) + + def test_setstate_errors(self): + f = self.partial(signature) + self.assertRaises(TypeError, f.__setstate__, (capture, (), {})) + self.assertRaises(TypeError, f.__setstate__, (capture, (), {}, {}, None)) + self.assertRaises(TypeError, f.__setstate__, [capture, (), {}, None]) + self.assertRaises(TypeError, f.__setstate__, (None, (), {}, None)) + self.assertRaises(TypeError, f.__setstate__, (capture, None, {}, None)) + self.assertRaises(TypeError, f.__setstate__, (capture, [], {}, None)) + self.assertRaises(TypeError, f.__setstate__, (capture, (), [], None)) + + def test_setstate_subclasses(self): + f = self.partial(signature) + f.__setstate__((capture, MyTuple((1,)), MyDict(a=10), None)) + s = signature(f) + self.assertEqual(s, (capture, (1,), dict(a=10), {})) + self.assertIs(type(s[1]), tuple) + self.assertIs(type(s[2]), dict) + r = f() + self.assertEqual(r, ((1,), {'a': 10})) + self.assertIs(type(r[0]), tuple) + self.assertIs(type(r[1]), dict) + + f.__setstate__((capture, BadTuple((1,)), {}, None)) + s = signature(f) + self.assertEqual(s, (capture, (1,), {}, {})) + self.assertIs(type(s[1]), tuple) + r = f(2) + self.assertEqual(r, ((1, 2), {})) + self.assertIs(type(r[0]), tuple) # Issue 6083: Reference counting bug def test_setstate_refcount(self): @@ -229,9 +312,7 @@ raise IndexError f = self.partial(object) - self.assertRaisesRegex(SystemError, - "new style getargs format but argument is not a tuple", - f.__setstate__, BadSequence()) + self.assertRaises(TypeError, f.__setstate__, BadSequence()) class TestPartialPy(TestPartial, unittest.TestCase): diff --git a/Misc/NEWS b/Misc/NEWS --- a/Misc/NEWS +++ b/Misc/NEWS @@ -70,6 +70,11 @@ Library ------- +- Issue #25945: Fixed a crash when unpickle the functools.partial object with + wrong state. Fixed a leak in failed functools.partial constructor. + "args" and "keywords" attributes of functools.partial have now always types + tuple and dict correspondingly. + - Issue #26202: copy.deepcopy() now correctly copies range() objects with non-atomic attributes. diff --git a/Modules/_functoolsmodule.c b/Modules/_functoolsmodule.c --- a/Modules/_functoolsmodule.c +++ b/Modules/_functoolsmodule.c @@ -34,7 +34,7 @@ return NULL; } - pargs = pkw = Py_None; + pargs = pkw = NULL; func = PyTuple_GET_ITEM(args, 0); if (Py_TYPE(func) == &partial_type && type == &partial_type) { partialobject *part = (partialobject *)func; @@ -42,6 +42,8 @@ pargs = part->args; pkw = part->kw; func = part->fn; + assert(PyTuple_Check(pargs)); + assert(PyDict_Check(pkw)); } } if (!PyCallable_Check(func)) { @@ -60,12 +62,10 @@ nargs = PyTuple_GetSlice(args, 1, PY_SSIZE_T_MAX); if (nargs == NULL) { - pto->args = NULL; - pto->kw = NULL; Py_DECREF(pto); return NULL; } - if (pargs == Py_None || PyTuple_GET_SIZE(pargs) == 0) { + if (pargs == NULL || PyTuple_GET_SIZE(pargs) == 0) { pto->args = nargs; Py_INCREF(nargs); } @@ -76,47 +76,36 @@ else { pto->args = PySequence_Concat(pargs, nargs); if (pto->args == NULL) { - pto->kw = NULL; + Py_DECREF(nargs); Py_DECREF(pto); return NULL; } + assert(PyTuple_Check(pto->args)); } Py_DECREF(nargs); - if (kw != NULL) { - if (pkw == Py_None) { - pto->kw = PyDict_Copy(kw); + if (pkw == NULL || PyDict_Size(pkw) == 0) { + if (kw == NULL) { + pto->kw = PyDict_New(); } else { - pto->kw = PyDict_Copy(pkw); - if (pto->kw != NULL) { - if (PyDict_Merge(pto->kw, kw, 1) != 0) { - Py_DECREF(pto); - return NULL; - } - } - } - if (pto->kw == NULL) { - Py_DECREF(pto); - return NULL; + Py_INCREF(kw); + pto->kw = kw; } } else { - if (pkw == Py_None) { - pto->kw = PyDict_New(); - if (pto->kw == NULL) { + pto->kw = PyDict_Copy(pkw); + if (kw != NULL && pto->kw != NULL) { + if (PyDict_Merge(pto->kw, kw, 1) != 0) { Py_DECREF(pto); return NULL; } } - else { - pto->kw = pkw; - Py_INCREF(pkw); - } } - - pto->weakreflist = NULL; - pto->dict = NULL; + if (pto->kw == NULL) { + Py_DECREF(pto); + return NULL; + } return (PyObject *)pto; } @@ -138,11 +127,11 @@ partial_call(partialobject *pto, PyObject *args, PyObject *kw) { PyObject *ret; - PyObject *argappl = NULL, *kwappl = NULL; + PyObject *argappl, *kwappl; assert (PyCallable_Check(pto->fn)); assert (PyTuple_Check(pto->args)); - assert (pto->kw == Py_None || PyDict_Check(pto->kw)); + assert (PyDict_Check(pto->kw)); if (PyTuple_GET_SIZE(pto->args) == 0) { argappl = args; @@ -154,11 +143,12 @@ argappl = PySequence_Concat(pto->args, args); if (argappl == NULL) return NULL; + assert(PyTuple_Check(argappl)); } - if (pto->kw == Py_None) { + if (PyDict_Size(pto->kw) == 0) { kwappl = kw; - Py_XINCREF(kw); + Py_XINCREF(kwappl); } else { kwappl = PyDict_Copy(pto->kw); if (kwappl == NULL) { @@ -217,6 +207,7 @@ PyObject *arglist; PyObject *tmp; Py_ssize_t i, n; + PyObject *key, *value; arglist = PyUnicode_FromString(""); if (arglist == NULL) { @@ -234,17 +225,14 @@ arglist = tmp; } /* Pack keyword arguments */ - assert (pto->kw == Py_None || PyDict_Check(pto->kw)); - if (pto->kw != Py_None) { - PyObject *key, *value; - for (i = 0; PyDict_Next(pto->kw, &i, &key, &value);) { - tmp = PyUnicode_FromFormat("%U, %U=%R", arglist, - key, value); - Py_DECREF(arglist); - if (tmp == NULL) - return NULL; - arglist = tmp; - } + assert (PyDict_Check(pto->kw)); + for (i = 0; PyDict_Next(pto->kw, &i, &key, &value);) { + tmp = PyUnicode_FromFormat("%U, %U=%R", arglist, + key, value); + Py_DECREF(arglist); + if (tmp == NULL) + return NULL; + arglist = tmp; } result = PyUnicode_FromFormat("%s(%R%U)", Py_TYPE(pto)->tp_name, pto->fn, arglist); @@ -271,25 +259,45 @@ partial_setstate(partialobject *pto, PyObject *state) { PyObject *fn, *fnargs, *kw, *dict; - if (!PyArg_ParseTuple(state, "OOOO", - &fn, &fnargs, &kw, &dict)) + + if (!PyTuple_Check(state) || + !PyArg_ParseTuple(state, "OOOO", &fn, &fnargs, &kw, &dict) || + !PyCallable_Check(fn) || + !PyTuple_Check(fnargs) || + (kw != Py_None && !PyDict_Check(kw))) + { + PyErr_SetString(PyExc_TypeError, "invalid partial state"); return NULL; - Py_XDECREF(pto->fn); - Py_XDECREF(pto->args); - Py_XDECREF(pto->kw); - Py_XDECREF(pto->dict); - pto->fn = fn; - pto->args = fnargs; - pto->kw = kw; - if (dict != Py_None) { - pto->dict = dict; - Py_INCREF(dict); - } else { - pto->dict = NULL; } + + if(!PyTuple_CheckExact(fnargs)) + fnargs = PySequence_Tuple(fnargs); + else + Py_INCREF(fnargs); + if (fnargs == NULL) + return NULL; + + if (kw == Py_None) + kw = PyDict_New(); + else if(!PyDict_CheckExact(kw)) + kw = PyDict_Copy(kw); + else + Py_INCREF(kw); + if (kw == NULL) { + Py_DECREF(fnargs); + return NULL; + } + Py_INCREF(fn); - Py_INCREF(fnargs); - Py_INCREF(kw); + if (dict == Py_None) + dict = NULL; + else + Py_INCREF(dict); + + Py_SETREF(pto->fn, fn); + Py_SETREF(pto->args, fnargs); + Py_SETREF(pto->kw, kw); + Py_SETREF(pto->dict, dict); Py_RETURN_NONE; } -- Repository URL: https://hg.python.org/cpython

1 0

cpython (2.7): Issue #25945: Fixed bugs in functools.partial.
by serhiy.storchaka 02 Feb '16

02 Feb '16

https://hg.python.org/cpython/rev/628ce2975e29 changeset: 100149:628ce2975e29 branch: 2.7 parent: 100144:650cf38fba28 user: Serhiy Storchaka <storchaka(a)gmail.com> date: Tue Feb 02 18:45:59 2016 +0200 summary: Issue #25945: Fixed bugs in functools.partial. Fixed a crash when unpickle the functools.partial object with wrong state. Fixed a leak in failed functools.partial constructor. "args" and "keywords" attributes of functools.partial have now always types tuple and dict correspondingly. files: Lib/test/test_functools.py | 101 +++++++++++++++++++++++- Misc/NEWS | 5 + Modules/_functoolsmodule.c | 66 ++++++++++------ 3 files changed, 142 insertions(+), 30 deletions(-) diff --git a/Lib/test/test_functools.py b/Lib/test/test_functools.py --- a/Lib/test/test_functools.py +++ b/Lib/test/test_functools.py @@ -1,3 +1,4 @@ +import copy import functools import sys import unittest @@ -25,6 +26,16 @@ """ return the signature of a partial object """ return (part.func, part.args, part.keywords, part.__dict__) +class MyTuple(tuple): + pass + +class BadTuple(tuple): + def __add__(self, other): + return list(self) + list(other) + +class MyDict(dict): + pass + class TestPartial(unittest.TestCase): thetype = functools.partial @@ -146,11 +157,84 @@ self.assertEqual(join(data), '0123456789') def test_pickle(self): - f = self.thetype(signature, 'asdf', bar=True) - f.add_something_to__dict__ = True + f = self.thetype(signature, ['asdf'], bar=[True]) + f.attr = [] for proto in range(pickle.HIGHEST_PROTOCOL + 1): f_copy = pickle.loads(pickle.dumps(f, proto)) - self.assertEqual(signature(f), signature(f_copy)) + self.assertEqual(signature(f_copy), signature(f)) + + def test_copy(self): + f = self.thetype(signature, ['asdf'], bar=[True]) + f.attr = [] + f_copy = copy.copy(f) + self.assertEqual(signature(f_copy), signature(f)) + self.assertIs(f_copy.attr, f.attr) + self.assertIs(f_copy.args, f.args) + self.assertIs(f_copy.keywords, f.keywords) + + def test_deepcopy(self): + f = self.thetype(signature, ['asdf'], bar=[True]) + f.attr = [] + f_copy = copy.deepcopy(f) + self.assertEqual(signature(f_copy), signature(f)) + self.assertIsNot(f_copy.attr, f.attr) + self.assertIsNot(f_copy.args, f.args) + self.assertIsNot(f_copy.args[0], f.args[0]) + self.assertIsNot(f_copy.keywords, f.keywords) + self.assertIsNot(f_copy.keywords['bar'], f.keywords['bar']) + + def test_setstate(self): + f = self.thetype(signature) + f.__setstate__((capture, (1,), dict(a=10), dict(attr=[]))) + self.assertEqual(signature(f), + (capture, (1,), dict(a=10), dict(attr=[]))) + self.assertEqual(f(2, b=20), ((1, 2), {'a': 10, 'b': 20})) + + f.__setstate__((capture, (1,), dict(a=10), None)) + self.assertEqual(signature(f), (capture, (1,), dict(a=10), {})) + self.assertEqual(f(2, b=20), ((1, 2), {'a': 10, 'b': 20})) + + f.__setstate__((capture, (1,), None, None)) + #self.assertEqual(signature(f), (capture, (1,), {}, {})) + self.assertEqual(f(2, b=20), ((1, 2), {'b': 20})) + self.assertEqual(f(2), ((1, 2), {})) + self.assertEqual(f(), ((1,), {})) + + f.__setstate__((capture, (), {}, None)) + self.assertEqual(signature(f), (capture, (), {}, {})) + self.assertEqual(f(2, b=20), ((2,), {'b': 20})) + self.assertEqual(f(2), ((2,), {})) + self.assertEqual(f(), ((), {})) + + def test_setstate_errors(self): + f = self.thetype(signature) + self.assertRaises(TypeError, f.__setstate__, (capture, (), {})) + self.assertRaises(TypeError, f.__setstate__, (capture, (), {}, {}, None)) + self.assertRaises(TypeError, f.__setstate__, [capture, (), {}, None]) + self.assertRaises(TypeError, f.__setstate__, (None, (), {}, None)) + self.assertRaises(TypeError, f.__setstate__, (capture, None, {}, None)) + self.assertRaises(TypeError, f.__setstate__, (capture, [], {}, None)) + self.assertRaises(TypeError, f.__setstate__, (capture, (), [], None)) + + def test_setstate_subclasses(self): + f = self.thetype(signature) + f.__setstate__((capture, MyTuple((1,)), MyDict(a=10), None)) + s = signature(f) + self.assertEqual(s, (capture, (1,), dict(a=10), {})) + self.assertIs(type(s[1]), tuple) + self.assertIs(type(s[2]), dict) + r = f() + self.assertEqual(r, ((1,), {'a': 10})) + self.assertIs(type(r[0]), tuple) + self.assertIs(type(r[1]), dict) + + f.__setstate__((capture, BadTuple((1,)), {}, None)) + s = signature(f) + self.assertEqual(s, (capture, (1,), {}, {})) + self.assertIs(type(s[1]), tuple) + r = f(2) + self.assertEqual(r, ((1, 2), {})) + self.assertIs(type(r[0]), tuple) # Issue 6083: Reference counting bug def test_setstate_refcount(self): @@ -167,7 +251,7 @@ raise IndexError f = self.thetype(object) - self.assertRaises(SystemError, f.__setstate__, BadSequence()) + self.assertRaises(TypeError, f.__setstate__, BadSequence()) class PartialSubclass(functools.partial): pass @@ -181,7 +265,14 @@ thetype = PythonPartial # the python version isn't picklable - test_pickle = test_setstate_refcount = None + test_pickle = None + test_setstate = None + test_setstate_errors = None + test_setstate_subclasses = None + test_setstate_refcount = None + + # the python version isn't deepcopyable + test_deepcopy = None # the python version isn't a type test_attributes = None diff --git a/Misc/NEWS b/Misc/NEWS --- a/Misc/NEWS +++ b/Misc/NEWS @@ -48,6 +48,11 @@ Library ------- +- Issue #25945: Fixed a crash when unpickle the functools.partial object with + wrong state. Fixed a leak in failed functools.partial constructor. + "args" and "keywords" attributes of functools.partial have now always types + tuple and dict correspondingly. + - Issue #19883: Fixed possible integer overflows in zipimport. - Issue #26147: xmlrpclib now works with unicode not encodable with used diff --git a/Modules/_functoolsmodule.c b/Modules/_functoolsmodule.c --- a/Modules/_functoolsmodule.c +++ b/Modules/_functoolsmodule.c @@ -128,7 +128,6 @@ Py_INCREF(func); pto->args = PyTuple_GetSlice(args, 1, PY_SSIZE_T_MAX); if (pto->args == NULL) { - pto->kw = NULL; Py_DECREF(pto); return NULL; } @@ -138,10 +137,6 @@ return NULL; } - - pto->weakreflist = NULL; - pto->dict = NULL; - return (PyObject *)pto; } @@ -162,11 +157,11 @@ partial_call(partialobject *pto, PyObject *args, PyObject *kw) { PyObject *ret; - PyObject *argappl = NULL, *kwappl = NULL; + PyObject *argappl, *kwappl; assert (PyCallable_Check(pto->fn)); assert (PyTuple_Check(pto->args)); - assert (pto->kw == Py_None || PyDict_Check(pto->kw)); + assert (PyDict_Check(pto->kw)); if (PyTuple_GET_SIZE(pto->args) == 0) { argappl = args; @@ -178,11 +173,12 @@ argappl = PySequence_Concat(pto->args, args); if (argappl == NULL) return NULL; + assert(PyTuple_Check(argappl)); } - if (pto->kw == Py_None) { + if (PyDict_Size(pto->kw) == 0) { kwappl = kw; - Py_XINCREF(kw); + Py_XINCREF(kwappl); } else { kwappl = PyDict_Copy(pto->kw); if (kwappl == NULL) { @@ -289,25 +285,45 @@ partial_setstate(partialobject *pto, PyObject *state) { PyObject *fn, *fnargs, *kw, *dict; - if (!PyArg_ParseTuple(state, "OOOO", - &fn, &fnargs, &kw, &dict)) + + if (!PyTuple_Check(state) || + !PyArg_ParseTuple(state, "OOOO", &fn, &fnargs, &kw, &dict) || + !PyCallable_Check(fn) || + !PyTuple_Check(fnargs) || + (kw != Py_None && !PyDict_Check(kw))) + { + PyErr_SetString(PyExc_TypeError, "invalid partial state"); return NULL; - Py_XDECREF(pto->fn); - Py_XDECREF(pto->args); - Py_XDECREF(pto->kw); - Py_XDECREF(pto->dict); - pto->fn = fn; - pto->args = fnargs; - pto->kw = kw; - if (dict != Py_None) { - pto->dict = dict; - Py_INCREF(dict); - } else { - pto->dict = NULL; } + + if(!PyTuple_CheckExact(fnargs)) + fnargs = PySequence_Tuple(fnargs); + else + Py_INCREF(fnargs); + if (fnargs == NULL) + return NULL; + + if (kw == Py_None) + kw = PyDict_New(); + else if(!PyDict_CheckExact(kw)) + kw = PyDict_Copy(kw); + else + Py_INCREF(kw); + if (kw == NULL) { + Py_DECREF(fnargs); + return NULL; + } + Py_INCREF(fn); - Py_INCREF(fnargs); - Py_INCREF(kw); + if (dict == Py_None) + dict = NULL; + else + Py_INCREF(dict); + + Py_SETREF(pto->fn, fn); + Py_SETREF(pto->args, fnargs); + Py_SETREF(pto->kw, kw); + Py_SETREF(pto->dict, dict); Py_RETURN_NONE; } -- Repository URL: https://hg.python.org/cpython

1 0