docs: def feature_needs(*feas):
      """
      Get info about the FUSE API version needed for the support of some features.
  
      This function takes a variable number of feature patterns.
  
      A feature pattern is either:
  
      -  an integer (directly referring to a FUSE API version number)
      -  a built-in feature specifier string (meaning defined by dictionary)
      -  a string of the form ``has_foo``, where ``foo`` is a filesystem method
         (refers to the API version where the method has been introduced)
      -  a list/tuple of other feature patterns (matches each of its members)
      -  a regexp (meant to be matched against the builtins plus ``has_foo``
         patterns; can also be given by a string of the from "re:*")
      -  a negated regexp (can be given by a string of the form "!re:*")
  
      If called with no arguments, then the list of builtins is returned, mapped
      to their meaning.
  
      Otherwise the function returns the smallest FUSE API version number which
      has all the matching features.
  
      Builtin specifiers worth to explicit mention:
      - ``stateful_files``: you want to use custom filehandles (eg. a file class).
      - ``*``: you want all features.
      - while ``has_foo`` makes sense for all filesystem method ``foo``, some
        of these can be found among the builtins, too (the ones which can be
        handled by the general rule).
  
      specifiers like ``has_foo`` refer to requirement that the library knows of
        the fs method ``foo``.
      """
  
      fmap = {'stateful_files': 22,
              'stateful_dirs':  23,
              'stateful_io':    ('stateful_files', 'stateful_dirs'),
              'stateful_files_keep_cache': 23,
              'stateful_files_direct_io': 23,
              'keep_cache':     ('stateful_files_keep_cache',),
              'direct_io':      ('stateful_files_direct_io',),
              'has_opendir':    ('stateful_dirs',),
              'has_releasedir': ('stateful_dirs',),
              'has_fsyncdir':   ('stateful_dirs',),
              'has_create':     25,
              'has_access':     25,
              'has_fgetattr':   25,
              'has_ftruncate':  25,
              'has_fsinit':     ('has_init'),
              'has_fsdestroy':  ('has_destroy'),
              'has_lock':       26,
              'has_utimens':    26,
              'has_bmap':       26,
              'has_init':       23,
              'has_destroy':    23,
              '*':              '!re:^\*$'}
  
      if not feas:
          return fmap
  
      def resolve(args, maxva):
  
          for fp in args:
              if isinstance(fp, int):
                  maxva[0] = max(maxva[0], fp)
                  continue
              if isinstance(fp, list) or isinstance(fp, tuple):
                  for f in fp:
                      yield f
                  continue
              ma = isinstance(fp, str) and re.compile("(!\s*|)re:(.*)").match(fp)
              if isinstance(fp, type(re.compile(''))) or ma:
                  neg = False
                  if ma:
                      mag = ma.groups()
                      fp = re.compile(mag[1])
                      neg = bool(mag[0])
                  for f in list(fmap.keys()) + [ 'has_' + a for a in Fuse._attrs ]:
                      if neg != bool(re.search(fp, f)):
                          yield f
                  continue
              ma = re.compile("has_(.*)").match(fp)
              if ma and ma.groups()[0] in Fuse._attrs and not fp in fmap:
                  yield 21
                  continue
              yield fmap[fp]
  
      maxva = [0]
      while feas:
          feas = set(resolve(feas, maxva))
  
      return maxva[0]