docs: def config(maybe_cls=None, these=None, title=None, description=None):
      """ File config class decorator.
  
      Usage is to simply decorate a **class** to make it a
      :func:`config <file_config._file_config.config>` class.
  
      >>> import file_config
      >>> @file_config.config(
              title="My Config Title",
              description="A description about my config"
          )
          class MyConfig(object):
              pass
  
      :param class maybe_cls: The class to inherit from, defaults to None, optional
      :param dict these: A dictionary of str to ``file_config.var`` to use as attribs
      :param str title: The title of the config, defaults to None, optional
      :param str description: A description of the config, defaults to None, optional
      :return: Config wrapped class
      :rtype: class
      """
  
      def wrap(config_cls):
          """ The wrapper function.
  
          :param class config_cls: The class to wrap
          :return: The config_cls wrapper
          :rtype: class
          """
  
          setattr(config_cls, CONFIG_KEY, dict(title=title, description=description))
          # dynamically assign available handlers to the wrapped class
          for handler_name in handlers.__all__:
              handler = getattr(handlers, handler_name)
              if handler.available:
                  handler = handler()
                  setattr(
                      config_cls,
                      f"dumps_{handler.name}",
                      partialmethod(_handle_dumps, handler),
                  )
                  setattr(
                      config_cls,
                      f"dump_{handler.name}",
                      partialmethod(_handle_dump, handler),
                  )
                  setattr(
                      config_cls,
                      f"loads_{handler.name}",
                      partialmethod(_handle_loads, handler),
                  )
                  setattr(
                      config_cls,
                      f"load_{handler.name}",
                      partialmethod(_handle_load, handler),
                  )
          config_vars = these if isinstance(these, dict) else None
          return attr.s(config_cls, these=config_vars, slots=True)
  
      if maybe_cls is None:
          return wrap
      else:
          return wrap(maybe_cls)