Replace `%averbose` with args to `%autoreload`

IPython/extensions/autoreload.py

@@ -53,6 +53,10 b' The following magic commands are provided:'
     Same as 2/all, but also adds any new objects in the module. See
     unit test at IPython/extensions/tests/test_autoreload.py::test_autoload_newly_added_objects
 
+  Adding ``--print`` or ``-p`` to the ``%autoreload`` line will print autoreload activity to
+  standard out. ``--log`` or ``-l`` will do it to the log at INFO level; both can be used
+  simultaneously.
+
 ``%aimport``
 
     List modules which are to be automatically imported or not to be imported.
@@ -69,18 +73,6 b' The following magic commands are provided:'
 
     Mark module 'foo' to not be autoreloaded.
 
-``%averbose off``
-
-    Perform autoreload tasks quietly
-
-``%averbose on``
-
-    Report activity with `print` statements.
-
-``%averbose log``
-
-    Report activity with the logger.
-
 Caveats
 =======
 
@@ -113,6 +105,7 b' Some of the known remaining caveats are:'
 - Reloading a module, or importing the same module by a different name, creates new Enums. These may look the same, but are not.
 """
 
+from IPython.core import magic_arguments
 from IPython.core.magic import Magics, magics_class, line_magic
 
 __skip_doctest__ = True
@@ -525,7 +518,28 b' class AutoreloadMagics(Magics):'
         self.loaded_modules = set(sys.modules)
 
     @line_magic
-    def autoreload(self, parameter_s=""):
+    @magic_arguments.magic_arguments()
+    @magic_arguments.argument('mode', type=str, default='now', nargs='?',
+                              help="""
+                              blank or 'now' - Reload all modules (except those excluded by
+                                %%aimport) automaticallynow.
+                              
+                              '0' or 'off' - Disable automatic reloading.
+
+                              '1' or 'explicit' - Reload only modules imported with %%aimport every
+                                time before executing the Python code typed.
+
+                              '2' or 'all' - Reload all modules (except those excluded by %%aimport)
+                                every time before executing the Python code typed.
+
+                              '3' or 'complete' - Same as 2/all, but also but also adds any new
+                                objects in the module.
+                              """)
+    @magic_arguments.argument('-p', '--print', action='store_true', default=False,
+                              help='Show autoreload activity using `print` statements')
+    @magic_arguments.argument('-l', '--log', action='store_true', default=False,
+                              help='Show autoreload activity using the logger')
+    def autoreload(self, line=""):
         r"""%autoreload => Reload modules automatically
 
         %autoreload or %autoreload now
@@ -547,6 +561,10 b' class AutoreloadMagics(Magics):'
         Same as 2/all, but also but also adds any new objects in the module. See
         unit test at IPython/extensions/tests/test_autoreload.py::test_autoload_newly_added_objects
 
+        The optional arguments --print and --log control display of autoreload activity. The default
+        is to act silently; --print (or -p) will print out the names of modules that are being
+        reloaded, and --log (or -l) outputs them to the log at INFO level.
+
         Reloading Python modules in a reliable way is in general
         difficult, and unexpected things may occur. %autoreload tries to
         work around common pitfalls by replacing function code objects and
@@ -573,23 +591,45 b' class AutoreloadMagics(Magics):'
           autoreloaded.
 
         """
-        parameter_s_lower = parameter_s.lower()
-        if parameter_s == "" or parameter_s_lower == "now":
+        args = magic_arguments.parse_argstring(self.autoreload, line)
+        mode = args.mode.lower()
+        
+        def p(msg):
+            print(msg)
+            
+        def l(msg):
+            logging.getLogger("autoreload").info(msg)
+
+        def pl(msg):
+            p(msg)
+            l(msg)
+
+        if args.print is False and args.log is False:
+            self._reloader._report = lambda msg: None
+        elif args.print is True:
+            if args.log is True:
+                self._reloader._report = lambda msg: pl(msg)
+            else:
+                self._reloader._report = lambda msg: p(msg)
+        elif args.log is True:
+            self._reloader._report = lambda msg: l(msg)
+
+        if mode == "" or mode == "now":
             self._reloader.check(True)
-        elif parameter_s == "0" or parameter_s_lower == "off":
+        elif mode == "0" or mode == "off":
             self._reloader.enabled = False
-        elif parameter_s == "1" or parameter_s_lower == "explicit":
+        elif mode == "1" or mode == "explicit":
             self._reloader.check_all = False
             self._reloader.enabled = True
-        elif parameter_s == "2" or parameter_s_lower == "all":
+        elif mode == "2" or mode == "all":
             self._reloader.check_all = True
             self._reloader.enabled = True
-        elif parameter_s == "3" or parameter_s_lower == "complete":
+        elif mode == "3" or mode == "complete":
             self._reloader.check_all = True
             self._reloader.enabled = True
             self._reloader.autoload_obj = True
         else:
-            raise ValueError(f'Unrecognized parameter "{parameter_s}".')
+            raise ValueError(f'Unrecognized autoreload mode "{mode}".')
 
     @line_magic
     def aimport(self, parameter_s="", stream=None):
@@ -630,31 +670,6 b' class AutoreloadMagics(Magics):'
                     # Inject module to user namespace
                     self.shell.push({top_name: top_module})
 
-    @line_magic
-    def averbose(self, parameter_s=""):
-        r"""%averbose => Turn verbosity on/off for autoreloading.
-
-        %averbose 0 or %averbose off
-        Turn off any reporting during autoreload.
-
-        %averbose 1 or %averbose on
-        Report autoreload activity via print statements.
-
-        %averbose 2 or %averbose log
-        Report autoreload activity via logging.
-        """
-
-        if parameter_s == "0" or parameter_s.lower() == "off":
-            self._reloader._report = lambda msg: None
-        elif parameter_s == "1" or parameter_s.lower() == "on":
-            self._reloader._report = lambda msg: print(msg)
-        elif parameter_s == "2" or parameter_s.lower() == "log":
-            self._reloader._report = lambda msg: logging.getLogger("autoreload").info(
-                msg
-            )
-        else:
-            raise ValueError(f'Unrecognized parameter "{parameter_s}".')
-
     def pre_run_cell(self):
         if self._reloader.enabled:
             try:

IPython/extensions/tests/test_autoreload.py

@@ -71,9 +71,6 b' class FakeShell:'
         self.auto_magics.aimport(parameter, stream=stream)
         self.auto_magics.post_execute_hook()
 
-    def magic_averbose(self, parameter):
-        self.auto_magics.averbose(parameter)
-
 class Fixture(TestCase):
     """Fixture for creating test module files"""
 
@@ -442,41 +439,40 b' class TestAutoreload(Fixture):'
         assert module_reloader.skip_modules["os"] is True
         assert "os" not in module_reloader.modules.keys()
 
-    def test_averbose(self):
-        self.shell.magic_averbose("off")
+    def test_autoreload_output(self):
         self.shell.magic_autoreload("complete")
         mod_code = """
         def func1(): pass
         """
         mod_name, mod_fn = self.new_module(mod_code)
         self.shell.run_code(f"import {mod_name}")
-        with tt.AssertPrints("", channel="stdout"):  # no output.
+        with tt.AssertPrints("", channel="stdout"):  # no output; this is default
             self.shell.run_code("pass")
 
+        self.shell.magic_autoreload("complete --print")
         self.write_file(mod_fn, mod_code)  # "modify" the module
-        self.shell.magic_averbose("on")  # Should now see a print statement.
-        with tt.AssertPrints(f"Reloading '{mod_name}'.", channel="stdout"):
+        with tt.AssertPrints(f"Reloading '{mod_name}'.", channel="stdout"):  # see something printed out
             self.shell.run_code("pass")
 
+        self.shell.magic_autoreload("complete -p")
         self.write_file(mod_fn, mod_code)  # "modify" the module
-        self.shell.magic_averbose("off")  # Should not see anything on next call
-        with tt.AssertPrints("", channel="stdout"):
+        with tt.AssertPrints(f"Reloading '{mod_name}'.", channel="stdout"):  # see something printed out
             self.shell.run_code("pass")
 
-        # TODO: test logging. Why won't this work?
-        # with tt.AssertPrints('LOGGER: '):
-        #     self.shell.run_code("import logging; logging.basicConfig(format='LOGGER: %(message)s');"
-        #                         "logger = logging.getLogger(); logger.setLevel(logging.DEBUG);"
-        #                         "logger.info('test')")
-
-        # self.shell.magic_averbose("log")  # Should see it formatted as per our logging config
-        # self.write_file(mod_fn, mod_code)  # "modify" the module
-        # with tt.AssertPrints(f"LOGGER: Reloading '{mod_name}'.", channel="stdout"):
-        #     self.shell.run_code("pass")
+        self.shell.magic_autoreload("complete --print --log")
+        self.write_file(mod_fn, mod_code)  # "modify" the module
+        with tt.AssertPrints(f"Reloading '{mod_name}'.", channel="stdout"):  # see something printed out
+            self.shell.run_code("pass")
 
-        # And an invalid mode name raises an exception.
-        with self.assertRaises(ValueError):
-            self.shell.magic_averbose("fax")
+        # TODO: test logging, i.e. --log. Why won't this work?
+        # with tt.AssertPrints("LOGGER: test", channel="stdout"):
+        #     # logger.info('test')
+        #     self.shell.run_code("import logging; import sys;"
+        #                         "logging.basicConfig(format='LOGGER: %(message)s',"
+        #                         "                    stream=sys.stdout,"
+        #                         "                    level=logging.DEBUG);"
+        #                         "logging.getLogger().info('test');"
+        #     )
 
     def _check_smoketest(self, use_aimport=True):
         """

docs/source/whatsnew/pr/autoreload-verbosity.rst

@@ -10,12 +10,12 b' We introduce more descriptive names for the `%autoreload` parameter:'
 
 The original designations (e.g. "2") still work, and these new ones are case-insensitive.
 
+Additionally, the option `--print` or `-p` can be added to the line to print the names of modules
+being reloaded. Similarly, `--log` or `-l` will output the names to the logger at INFO level. Both
+can be used simultaneously.
+
 The parsing logic for `%aimport` is now improved such that modules can be whitelisted and
 blacklisted in the same line, e.g. it's now possible to call `%aimport os, -math` to include `os`
 for `%autoreload explicit` and exclude `math` for modes 2 and 3.
 
-A new magic command `%averbose` controls printing of the names of modules about to be autoreloaded.
-- `%averbose off` / `%averbose 0` - turns off all output (default behavior)
-- `%averbose on` / `%averbose 1`  - uses `print` to display module name
-- `%averbose log` / `%averbose 2` - logs an `INFO` message with the module name