code: def mirror(
      src_fs,  # type: Union[FS, Text]
      dst_fs,  # type: Union[FS, Text]
      walker=None,  # type: Optional[Walker]
      copy_if_newer=True,  # type: bool
      workers=0,  # type: int
  ):
      # type: (...) -> None
      
  
      def src():
          return manage_fs(src_fs, writeable=False)
  
      def dst():
          return manage_fs(dst_fs, create=True)
  
      with src() as _src_fs, dst() as _dst_fs:
          with _src_fs.lock(), _dst_fs.lock():
              _thread_safe = is_thread_safe(_src_fs, _dst_fs)
              with Copier(num_workers=workers if _thread_safe else 0) as copier:
                  _mirror(
                      _src_fs,
                      _dst_fs,
                      walker=walker,
                      copy_if_newer=copy_if_newer,
                      copy_file=copier.copy,
                  )
docs: Mirror files / directories from one filesystem to another.
  
      Mirroring a filesystem will create an exact copy of ``src_fs`` on
      ``dst_fs``, by removing any files / directories on the destination
      that aren't on the source, and copying files that aren't.
  
      Arguments:
          src_fs (FS or str): Source filesystem (URL or instance).
          dst_fs (FS or str): Destination filesystem (URL or instance).
          walker (~fs.walk.Walker, optional): An optional walker instance.
          copy_if_newer (bool): Only copy newer files (the default).
          workers (int): Number of worker threads used
              (0 for single threaded). Set to a relatively low number
              for network filesystems, 4 would be a good start.