docs: def start_reloader(
      worker_path,
      reload_interval=1,
      shutdown_interval=default,
      verbose=1,
      logger=None,
      monitor_factory=None,
      worker_args=None,
      worker_kwargs=None,
      ignore_files=None,
  ):
      """
      Start a monitor and then fork a worker process which starts by executing
      the importable function at ``worker_path``.
  
      If this function is called from a worker process that is already being
      monitored then it will return a reference to the current
      :class:`hupper.interfaces.IReloaderProxy` which can be used to
      communicate with the monitor.
  
      ``worker_path`` must be a dotted string pointing to a globally importable
      function that will be executed to start the worker. An example could be
      ``myapp.cli.main``. In most cases it will point at the same function that
      is invoking ``start_reloader`` in the first place.
  
      ``reload_interval`` is a value in seconds and will be used to throttle
      restarts. Default is ``1``.
  
      ``shutdown_interval`` is a value in seconds and will be used to trigger
      a graceful shutdown of the server. Set to ``None`` to disable the graceful
      shutdown. Default is the same as ``reload_interval``.
  
      ``verbose`` controls the output. Set to ``0`` to turn off any logging
      of activity and turn up to ``2`` for extra output. Default is ``1``.
  
      ``logger``, if supplied, supersedes ``verbose`` and should be an object
      implementing :class:`hupper.interfaces.ILogger`.
  
      ``monitor_factory`` is an instance of
      :class:`hupper.interfaces.IFileMonitorFactory`. If left unspecified, this
      will try to create a :class:`hupper.watchdog.WatchdogFileMonitor` if
      `watchdog <https://pypi.org/project/watchdog/>`_ is installed and will
      fallback to the less efficient
      :class:`hupper.polling.PollingFileMonitor` otherwise.
  
      If ``monitor_factory`` is ``None`` it can be overridden by the
      ``HUPPER_DEFAULT_MONITOR`` environment variable. It should be a dotted
      python path pointing at an object implementing
      :class:`hupper.interfaces.IFileMonitorFactory`.
  
      ``ignore_files`` if provided must be an iterable of shell-style patterns
      to ignore.
      """
      if is_active():
          return get_reloader()
  
      if logger is None:
          logger = DefaultLogger(verbose)
  
      if monitor_factory is None:
          monitor_factory = find_default_monitor_factory(logger)
  
      if shutdown_interval is default:
          shutdown_interval = reload_interval
  
      reloader = Reloader(
          worker_path=worker_path,
          worker_args=worker_args,
          worker_kwargs=worker_kwargs,
          reload_interval=reload_interval,
          shutdown_interval=shutdown_interval,
          monitor_factory=monitor_factory,
          logger=logger,
          ignore_files=ignore_files,
      )
      return reloader.run()