Remove the autorange fallback of timeit/repeat

Author: miikka

Doc/library/timeit.rst

@@ -62,39 +62,30 @@ Python Interface
 The module defines three convenience functions and a public class:
 
 
-.. function:: timeit(stmt='pass', setup='pass', timer=<default timer>, number=1000000, globals=None, target_time=0.2)
+.. function:: timeit(stmt='pass', setup='pass', timer=<default timer>, number=1000000, globals=None)
 
    Create a :class:`Timer` instance with the given statement, *setup* code and
    *timer* function and run its :meth:`.timeit` method with *number* executions.
    The optional *globals* argument specifies a namespace in which to execute the
-   code. If *number* is 0, :meth:`.autorange` method is executed, a convenience
-   function that calls :meth:`.timeit` repeatedly so that the total time >=
-   *target_time* second.
+   code.
 
    .. versionchanged:: 3.5
       The optional *globals* parameter was added.
 
-   .. versionchanged:: next
-      The optional *target_time* parameter was added.
 
-
-.. function:: repeat(stmt='pass', setup='pass', timer=<default timer>, repeat=5, number=1000000, globals=None, target_time=0.2)
+.. function:: repeat(stmt='pass', setup='pass', timer=<default timer>, repeat=5, number=1000000, globals=None)
 
    Create a :class:`Timer` instance with the given statement, *setup* code and
    *timer* function and run its :meth:`.repeat` method with the given *repeat*
    count and *number* executions.  The optional *globals* argument specifies a
-   namespace in which to execute the code. If *number* is 0, the :meth:`autorange`
-   method is executed, and a convenience function calls :meth:`timeit`
-   repeatedly so that the total time >= *target_time* seconds.
+   namespace in which to execute the code.
 
    .. versionchanged:: 3.5
       The optional *globals* parameter was added.
 
    .. versionchanged:: 3.7
       Default value of *repeat* changed from 3 to 5.
 
-   .. versionchanged:: next
-      The optional *target_time* parameter was added.
 
 .. function:: default_timer()
 
@@ -105,7 +96,7 @@ The module defines three convenience functions and a public class:
       :func:`time.perf_counter` is now the default timer.
 
 
-.. class:: Timer(stmt='pass', setup='pass', timer=<timer function>, globals=None, target_time=0.2)
+.. class:: Timer(stmt='pass', setup='pass', timer=<timer function>, globals=None)
 
    Class for timing execution speed of small code snippets.
 
@@ -131,9 +122,6 @@ The module defines three convenience functions and a public class:
    .. versionchanged:: 3.5
       The optional *globals* parameter was added.
 
-   .. versionchanged:: next
-      The optional *target_time* parameter was added.
-
    .. method:: Timer.timeit(number=1000000)
 
       Time *number* executions of the main statement.  This executes the setup
@@ -170,6 +158,8 @@ The module defines three convenience functions and a public class:
 
       .. versionadded:: 3.6
 
+      .. versionchanged:: next
+         The optional *target_time* parameter was added.
 
    .. method:: Timer.repeat(repeat=5, number=1000000)
 
@@ -253,7 +243,8 @@ Where the following options are understood:
 
 .. option:: -t, --target-time=T
 
-    calls :meth:`.timeit` repeatedly so that the total time >= *target_time* seconds
+   if :option:`--number` is 0, the code will run until it takes at
+   least this many seconds (default: 0.2)
 
    .. versionadded:: next
 
@@ -272,7 +263,7 @@ similarly.
 
 If :option:`-n` is not given, a suitable number of loops is calculated by trying
 increasing numbers from the sequence 1, 2, 5, 10, 20, 50, ... until the total
-time is at least 0.2 seconds.
+time is at least :option:`--target-time` seconds (default: 0.2).
 
 :func:`default_timer` measurements can be affected by other programs running on
 the same machine, so the best thing to do when accurate timing is necessary is

Lib/test/test_timeit.py

@@ -117,8 +117,8 @@ def timeit(self, stmt, setup, number=None, globals=None):
             kwargs['number'] = number
         delta_time = t.timeit(**kwargs)
         self.assertEqual(self.fake_timer.setup_calls, 1)
-        self.assertEqual(self.fake_timer.count, number or 1)
-        self.assertEqual(delta_time, number or (1, 1.0))
+        self.assertEqual(self.fake_timer.count, number)
+        self.assertEqual(delta_time, number)
 
     # Takes too long to run in debug build.
     #def test_timeit_default_iters(self):
@@ -149,12 +149,7 @@ def test_timeit_callable_stmt_and_setup(self):
     def test_timeit_function_zero_iters(self):
         delta_time = timeit.timeit(self.fake_stmt, self.fake_setup, number=0,
                 timer=FakeTimer())
-        self.assertEqual(delta_time, (1, 1.0))
-
-    def test_timeit_function_target_time(self):
-        delta_time = timeit.timeit(self.fake_stmt, self.fake_setup, number=0,
-                timer=FakeTimer(), target_time=1)
-        self.assertEqual(delta_time, (1, 1.0))
+        self.assertEqual(delta_time, 0)
 
     def test_timeit_globals_args(self):
         global _global_timer
@@ -167,9 +162,9 @@ def test_timeit_globals_args(self):
         timeit.timeit(stmt='local_timer.inc()', timer=local_timer,
                       globals=locals(), number=3)
 
-    def repeat(self, stmt, setup, repeat=None, number=None, target_time=0.5):
+    def repeat(self, stmt, setup, repeat=None, number=None):
         self.fake_timer = FakeTimer()
-        t = timeit.Timer(stmt=stmt, setup=setup, timer=self.fake_timer, target_time=target_time)
+        t = timeit.Timer(stmt=stmt, setup=setup, timer=self.fake_timer)
         kwargs = {}
         if repeat is None:
             repeat = DEFAULT_REPEAT
@@ -181,8 +176,8 @@ def repeat(self, stmt, setup, repeat=None, number=None, target_time=0.5):
             kwargs['number'] = number
         delta_times = t.repeat(**kwargs)
         self.assertEqual(self.fake_timer.setup_calls, repeat)
-        self.assertEqual(self.fake_timer.count, (repeat * number) if number else repeat)
-        self.assertEqual(delta_times, repeat * [float(number) or (1, 1.0)])
+        self.assertEqual(self.fake_timer.count, repeat * number)
+        self.assertEqual(delta_times, repeat * [float(number)])
 
     # Takes too long to run in debug build.
     #def test_repeat_default(self):
@@ -201,10 +196,6 @@ def test_repeat_callable_stmt(self):
         self.repeat(self.fake_callable_stmt, self.fake_setup,
                 repeat=3, number=5)
 
-    def test_repeat_callable_target_time(self):
-        self.repeat(self.fake_callable_stmt, self.fake_setup,
-                repeat=3, number=5, target_time=1)
-
     def test_repeat_callable_setup(self):
         self.repeat(self.fake_stmt, self.fake_callable_setup,
                 repeat=3, number=5)
@@ -227,7 +218,7 @@ def test_repeat_function_zero_reps(self):
     def test_repeat_function_zero_iters(self):
         delta_times = timeit.repeat(self.fake_stmt, self.fake_setup, number=0,
                 timer=FakeTimer())
-        self.assertEqual(delta_times, DEFAULT_REPEAT * [(1, 1.0)])
+        self.assertEqual(delta_times, DEFAULT_REPEAT * [0.0])
 
     def assert_exc_string(self, exc_string, expected_exc_name):
         exc_lines = exc_string.splitlines()
@@ -373,10 +364,10 @@ def test_main_exception_fixed_reps(self):
             s = self.run_main(switches=['-n1', '1/0'])
         self.assert_exc_string(error_stringio.getvalue(), 'ZeroDivisionError')
 
-    def autorange(self, seconds_per_increment=1/1024, callback=None):
+    def autorange(self, seconds_per_increment=1/1024, callback=None, target_time=0.2):
         timer = FakeTimer(seconds_per_increment=seconds_per_increment)
         t = timeit.Timer(stmt=self.fake_stmt, setup=self.fake_setup, timer=timer)
-        return t.autorange(callback)
+        return t.autorange(callback, target_time=target_time)
 
     def test_autorange(self):
         num_loops, time_taken = self.autorange()
@@ -388,6 +379,11 @@ def test_autorange_second(self):
         self.assertEqual(num_loops, 1)
         self.assertEqual(time_taken, 1.0)
 
+    def test_autorange_with_target_time(self):
+        num_loops, time_taken = self.autorange(target_time=1.0)
+        self.assertEqual(num_loops, 2000)
+        self.assertEqual(time_taken, 2000/1024)
+
     def test_autorange_with_callback(self):
         def callback(a, b):
             print("{} {:.3f}".format(a, b))

Lib/timeit.py

@@ -103,10 +103,9 @@ class Timer:
     """
 
     def __init__(self, stmt="pass", setup="pass", timer=default_timer,
-                 globals=None, target_time=default_target_time):
+                 globals=None):
         """Constructor.  See class doc string."""
         self.timer = timer
-        self.target_time = target_time
         local_ns = {}
         global_ns = _globals() if globals is None else globals
         init = ''
@@ -181,8 +180,6 @@ def timeit(self, number=default_number):
         to one million.  The main statement, the setup statement and
         the timer function to be used are passed to the constructor.
         """
-        if not number:
-            return self.autorange()
         it = itertools.repeat(None, number)
         gcold = gc.isenabled()
         gc.disable()
@@ -219,7 +216,7 @@ def repeat(self, repeat=default_repeat, number=default_number):
             r.append(t)
         return r
 
-    def autorange(self, callback=None, target_time=None):
+    def autorange(self, callback=None, target_time=default_target_time):
         """Return the number of loops and time taken so that
         total time >= target_time (default is 0.2 seconds).
 
@@ -230,8 +227,6 @@ def autorange(self, callback=None, target_time=None):
         If *callback* is given and is not None, it will be called after
         each trial with two arguments: ``callback(number, time_taken)``.
         """
-        if target_time is None:
-            target_time = self.target_time
         i = 1
         while True:
             for j in 1, 2, 5:
@@ -245,17 +240,15 @@ def autorange(self, callback=None, target_time=None):
 
 
 def timeit(stmt="pass", setup="pass", timer=default_timer,
-           number=default_number, globals=None,
-           target_time=default_target_time):
+           number=default_number, globals=None):
     """Convenience function to create Timer object and call timeit method."""
-    return Timer(stmt, setup, timer, globals, target_time).timeit(number)
+    return Timer(stmt, setup, timer, globals).timeit(number)
 
 
 def repeat(stmt="pass", setup="pass", timer=default_timer,
-           repeat=default_repeat, number=default_number,
-           globals=None, target_time=default_target_time):
+           repeat=default_repeat, number=default_number, globals=None):
     """Convenience function to create Timer object and call repeat method."""
-    return Timer(stmt, setup, timer, globals, target_time).repeat(repeat, number)
+    return Timer(stmt, setup, timer, globals).repeat(repeat, number)
 
 
 def main(args=None, *, _wrap_timer=None):
@@ -338,7 +331,7 @@ def main(args=None, *, _wrap_timer=None):
     if _wrap_timer is not None:
         timer = _wrap_timer(timer)
 
-    t = Timer(stmt, setup, timer, target_time=target_time)
+    t = Timer(stmt, setup, timer)
     if number == 0:
         # determine number so that total time >= target_time
         callback = None

Misc/NEWS.d/next/Library/2019-04-25-21-11-37.bpo-36461.TO5YyP.rst

@@ -1,5 +1,3 @@
-:mod:`timeit`:
-- added a new parameter *target_time* to :func:`timeit.timeit` and
-  :func:`timeit.repeat` methods and :class:`timeit.Timer` class;
-- had ``timeit`` and ``repeat`` methods (and functions) fall back
-  on ``autorange`` if the number is set to 0 or None.
+Make the target time of :meth:`timeit.Timer.autorange` configurable
+and add ``--target-time`` option to the command-line interface of
+:mod:`timeit`:.