code: def walk(
          self,
          fs,  # type: FS
          path="/",  # type: Text
          namespaces=None,  # type: Optional[Collection[Text]]
      ):
          # type: (...) -> Iterator[Step]
          
          _path = abspath(normpath(path))
          dir_info = defaultdict(list)  # type: MutableMapping[Text, List[Info]]
          _walk = self._iter_walk(fs, _path, namespaces=namespaces)
          for dir_path, info in _walk:
              if info is None:
                  dirs = []  # type: List[Info]
                  files = []  # type: List[Info]
                  for _info in dir_info[dir_path]:
                      (dirs if _info.is_dir else files).append(_info)
                  yield Step(dir_path, dirs, files)
                  del dir_info[dir_path]
              else:
                  dir_info[dir_path].append(info)
docs: Walk the directory structure of a filesystem.
  
          Arguments:
              fs (FS): A filesystem instance.
              path (str): A path to a directory on the filesystem.
              namespaces (list, optional): A list of additional namespaces
                  to add to the `Info` objects.
  
          Returns:
              collections.Iterator: an iterator of `~fs.walk.Step` instances.
  
          The return value is an iterator of ``(<path>, <dirs>, <files>)``
          named tuples,  where ``<path>`` is an absolute path to a
          directory, and ``<dirs>`` and ``<files>`` are a list of
          `~fs.info.Info` objects for directories and files in ``<path>``.
  
          Example:
              >>> home_fs = open_fs('~/')
              >>> walker = Walker(filter=['*.py'])
              >>> namespaces = ['details']
              >>> for path, dirs, files in walker.walk(home_fs, namespaces)
              ...    print("[{}]".format(path))
              ...    print("{} directories".format(len(dirs)))
              ...    total = sum(info.size for info in files)
              ...    print("{} bytes {}".format(total))