text: """Implementation of magic functions that control various automatic behaviors.
  """
  #-----------------------------------------------------------------------------
  #  Copyright (c) 2012 The IPython Development Team.
  #
  #  Distributed under the terms of the Modified BSD License.
  #
  #  The full license is in the file COPYING.txt, distributed with this software.
  #-----------------------------------------------------------------------------
  
  #-----------------------------------------------------------------------------
  # Imports
  #-----------------------------------------------------------------------------
  
  # Our own packages
  from IPython.core.magic import Bunch, Magics, magics_class, line_magic
  from IPython.testing.skipdoctest import skip_doctest
  from logging import error
  
  #-----------------------------------------------------------------------------
  # Magic implementation classes
  #-----------------------------------------------------------------------------
  
  @magics_class
  class AutoMagics(Magics):
      """Magics that control various autoX behaviors."""
  
      def __init__(self, shell):
          super(AutoMagics, self).__init__(shell)
          # namespace for holding state we may need
          self._magic_state = Bunch()
  
      @line_magic
      def automagic(self, parameter_s=''):
          """Make magic functions callable without having to type the initial %.
  
          Without arguments toggles on/off (when off, you must call it as
          %automagic, of course).  With arguments it sets the value, and you can
          use any of (case insensitive):
  
           - on, 1, True: to activate
  
           - off, 0, False: to deactivate.
  
          Note that magic functions have lowest priority, so if there's a
          variable whose name collides with that of a magic fn, automagic won't
          work for that function (you get the variable instead). However, if you
          delete the variable (del var), the previously shadowed magic function
          becomes visible to automagic again."""
  
          arg = parameter_s.lower()
          mman = self.shell.magics_manager
          if arg in ('on', '1', 'true'):
              val = True
          elif arg in ('off', '0', 'false'):
              val = False
          else:
              val = not mman.auto_magic
          mman.auto_magic = val
          print('\n' + self.shell.magics_manager.auto_status())
  
      @skip_doctest
      @line_magic
      def autocall(self, parameter_s=''):
          """Make functions callable without having to type parentheses.
  
          Usage:
  
             %autocall [mode]
  
          The mode can be one of: 0->Off, 1->Smart, 2->Full.  If not given, the
          value is toggled on and off (remembering the previous state).
  
          In more detail, these values mean:
  
          0 -> fully disabled
  
          1 -> active, but do not apply if there are no arguments on the line.
  
          In this mode, you get::
  
            In [1]: callable
            Out[1]: <built-in function callable>
  
            In [2]: callable 'hello'
            ------> callable('hello')
            Out[2]: False
  
          2 -> Active always.  Even if no arguments are present, the callable
          object is called::
  
            In [2]: float
            ------> float()
            Out[2]: 0.0
  
          Note that even with autocall off, you can still use '/' at the start of
          a line to treat the first argument on the command line as a function
          and add parentheses to it::
  
            In [8]: /str 43
            ------> str(43)
            Out[8]: '43'
  
          # all-random (note for auto-testing)
          """
  
          valid_modes = {
              0: "Off",
              1: "Smart",
              2: "Full",
          }
  
          def errorMessage() -> str:
              error = "Valid modes: "
              for k, v in valid_modes.items():
                  error += str(k) + "->" + v + ", "
              error = error[:-2]  # remove tailing `, ` after last element
              return error
  
          if parameter_s:
              if not parameter_s in map(str, valid_modes.keys()):
                  error(errorMessage())
                  return
              arg = int(parameter_s)
          else:
              arg = 'toggle'
  
          if not arg in (*list(valid_modes.keys()), "toggle"):
              error(errorMessage())
              return
  
          if arg in (valid_modes.keys()):
              self.shell.autocall = arg
          else: # toggle
              if self.shell.autocall:
                  self._magic_state.autocall_save = self.shell.autocall
                  self.shell.autocall = 0
              else:
                  try:
                      self.shell.autocall = self._magic_state.autocall_save
                  except AttributeError:
                      self.shell.autocall = self._magic_state.autocall_save = 1
  
          print("Automatic calling is:", list(valid_modes.values())[self.shell.autocall])
  