fsspec 2023.6.0__py3-none-any.whl → 2023.9.1__py3-none-any.whl

fsspec/tests/abstract/put.py

@@ -1,3 +1,11 @@
+from hashlib import md5
+from itertools import product
+
+import pytest
+
+from fsspec.tests.abstract.common import GLOB_EDGE_CASES_TESTS
+
+
 class AbstractPutTests:
     def test_put_file_to_existing_directory(
         self,
@@ -6,13 +14,14 @@ class AbstractPutTests:
         fs_target,
         local_join,
         local_bulk_operations_scenario_0,
+        supports_empty_directories,
     ):
         # Copy scenario 1a
         source = local_bulk_operations_scenario_0
 
         target = fs_target
         fs.mkdir(target)
-        if not self.supports_empty_directories():
+        if not supports_empty_directories:
             # Force target directory to exist by adding a dummy file
             fs.touch(fs_join(target, "dummy"))
         assert fs.isdir(target)
@@ -58,13 +67,23 @@ class AbstractPutTests:
         assert fs.isfile(fs_join(target, "newdir", "subfile1"))
 
     def test_put_file_to_file_in_existing_directory(
-        self, fs, fs_join, fs_target, local_join, local_bulk_operations_scenario_0
+        self,
+        fs,
+        fs_join,
+        fs_target,
+        local_join,
+        supports_empty_directories,
+        local_bulk_operations_scenario_0,
     ):
         # Copy scenario 1c
         source = local_bulk_operations_scenario_0
 
         target = fs_target
         fs.mkdir(target)
+        if not supports_empty_directories:
+            # Force target directory to exist by adding a dummy file
+            fs.touch(fs_join(target, "dummy"))
+        assert fs.isdir(target)
 
         fs.put(local_join(source, "subdir", "subfile1"), fs_join(target, "newfile"))
         assert fs.isfile(fs_join(target, "newfile"))
@@ -86,14 +105,19 @@ class AbstractPutTests:
         assert fs.isfile(fs_join(target, "newdir", "newfile"))
 
     def test_put_directory_to_existing_directory(
-        self, fs, fs_join, fs_target, local_bulk_operations_scenario_0
+        self,
+        fs,
+        fs_join,
+        fs_target,
+        local_bulk_operations_scenario_0,
+        supports_empty_directories,
     ):
         # Copy scenario 1e
         source = local_bulk_operations_scenario_0
 
         target = fs_target
         fs.mkdir(target)
-        if not self.supports_empty_directories():
+        if not supports_empty_directories:
             # Force target directory to exist by adding a dummy file
             dummy = fs_join(target, "dummy")
             fs.touch(dummy)
@@ -107,7 +131,7 @@ class AbstractPutTests:
 
             # Without recursive does nothing
             fs.put(s, t)
-            assert fs.ls(target) == [] if self.supports_empty_directories() else [dummy]
+            assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
 
             # With recursive
             fs.put(s, t, recursive=True)
@@ -118,7 +142,14 @@ class AbstractPutTests:
                 assert fs.isfile(fs_join(target, "nesteddir", "nestedfile"))
                 assert not fs.exists(fs_join(target, "subdir"))
 
-                fs.rm(fs.ls(target, detail=False), recursive=True)
+                fs.rm(
+                    [
+                        fs_join(target, "subfile1"),
+                        fs_join(target, "subfile2"),
+                        fs_join(target, "nesteddir"),
+                    ],
+                    recursive=True,
+                )
             else:
                 assert fs.isdir(fs_join(target, "subdir"))
                 assert fs.isfile(fs_join(target, "subdir", "subfile1"))
@@ -127,7 +158,7 @@ class AbstractPutTests:
                 assert fs.isfile(fs_join(target, "subdir", "nesteddir", "nestedfile"))
 
                 fs.rm(fs_join(target, "subdir"), recursive=True)
-            assert fs.ls(target) == [] if self.supports_empty_directories() else [dummy]
+            assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
 
             # Limit recursive by maxdepth
             fs.put(s, t, recursive=True, maxdepth=1)
@@ -137,7 +168,13 @@ class AbstractPutTests:
                 assert not fs.exists(fs_join(target, "nesteddir"))
                 assert not fs.exists(fs_join(target, "subdir"))
 
-                fs.rm(fs.ls(target, detail=False), recursive=True)
+                fs.rm(
+                    [
+                        fs_join(target, "subfile1"),
+                        fs_join(target, "subfile2"),
+                    ],
+                    recursive=True,
+                )
             else:
                 assert fs.isdir(fs_join(target, "subdir"))
                 assert fs.isfile(fs_join(target, "subdir", "subfile1"))
@@ -145,21 +182,21 @@ class AbstractPutTests:
                 assert not fs.exists(fs_join(target, "subdir", "nesteddir"))
 
                 fs.rm(fs_join(target, "subdir"), recursive=True)
-            assert fs.ls(target) == [] if self.supports_empty_directories() else [dummy]
+            assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
 
     def test_put_directory_to_new_directory(
-        self, fs, fs_join, fs_target, local_bulk_operations_scenario_0
+        self,
+        fs,
+        fs_join,
+        fs_target,
+        local_bulk_operations_scenario_0,
+        supports_empty_directories,
     ):
         # Copy scenario 1f
         source = local_bulk_operations_scenario_0
 
         target = fs_target
         fs.mkdir(target)
-        if not self.supports_empty_directories():
-            # Force target directory to exist by adding a dummy file
-            dummy = fs_join(target, "dummy")
-            fs.touch(dummy)
-        assert fs.isdir(target)
 
         for source_slash, target_slash in zip([False, True], [False, True]):
             s = fs_join(source, "subdir")
@@ -171,7 +208,11 @@ class AbstractPutTests:
 
             # Without recursive does nothing
             fs.put(s, t)
-            assert fs.ls(target) == [] if self.supports_empty_directories() else [dummy]
+            if supports_empty_directories:
+                assert fs.ls(target) == []
+            else:
+                with pytest.raises(FileNotFoundError):
+                    fs.ls(target)
 
             # With recursive
             fs.put(s, t, recursive=True)
@@ -197,14 +238,20 @@ class AbstractPutTests:
             assert not fs.exists(fs_join(target, "newdir"))
 
     def test_put_glob_to_existing_directory(
-        self, fs, fs_join, fs_target, local_join, local_bulk_operations_scenario_0
+        self,
+        fs,
+        fs_join,
+        fs_target,
+        local_join,
+        supports_empty_directories,
+        local_bulk_operations_scenario_0,
     ):
         # Copy scenario 1g
         source = local_bulk_operations_scenario_0
 
         target = fs_target
         fs.mkdir(target)
-        if not self.supports_empty_directories():
+        if not supports_empty_directories:
             # Force target directory to exist by adding a dummy file
             dummy = fs_join(target, "dummy")
             fs.touch(dummy)
@@ -221,29 +268,54 @@ class AbstractPutTests:
             assert not fs.exists(fs_join(target, "nesteddir", "nestedfile"))
             assert not fs.exists(fs_join(target, "subdir"))
 
-            fs.rm(fs.ls(target, detail=False), recursive=True)
-            assert fs.ls(target) == [] if self.supports_empty_directories() else [dummy]
+            fs.rm(
+                [
+                    fs_join(target, "subfile1"),
+                    fs_join(target, "subfile2"),
+                ],
+                recursive=True,
+            )
+            assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
 
             # With recursive
-            fs.put(local_join(source, "subdir", "*"), t, recursive=True)
-            assert fs.isfile(fs_join(target, "subfile1"))
-            assert fs.isfile(fs_join(target, "subfile2"))
-            assert fs.isdir(fs_join(target, "nesteddir"))
-            assert fs.isfile(fs_join(target, "nesteddir", "nestedfile"))
-            assert not fs.exists(fs_join(target, "subdir"))
-
-            fs.rm(fs.ls(target, detail=False), recursive=True)
-            assert fs.ls(target) == [] if self.supports_empty_directories() else [dummy]
+            for glob, recursive in zip(["*", "**"], [True, False]):
+                fs.put(local_join(source, "subdir", glob), t, recursive=recursive)
+                assert fs.isfile(fs_join(target, "subfile1"))
+                assert fs.isfile(fs_join(target, "subfile2"))
+                assert fs.isdir(fs_join(target, "nesteddir"))
+                assert fs.isfile(fs_join(target, "nesteddir", "nestedfile"))
+                assert not fs.exists(fs_join(target, "subdir"))
 
-            # Limit recursive by maxdepth
-            fs.put(local_join(source, "subdir", "*"), t, recursive=True, maxdepth=1)
-            assert fs.isfile(fs_join(target, "subfile1"))
-            assert fs.isfile(fs_join(target, "subfile2"))
-            assert not fs.exists(fs_join(target, "nesteddir"))
-            assert not fs.exists(fs_join(target, "subdir"))
+                fs.rm(
+                    [
+                        fs_join(target, "subfile1"),
+                        fs_join(target, "subfile2"),
+                        fs_join(target, "nesteddir"),
+                    ],
+                    recursive=True,
+                )
+                assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
+
+                # Limit recursive by maxdepth
+                fs.put(
+                    local_join(source, "subdir", glob),
+                    t,
+                    recursive=recursive,
+                    maxdepth=1,
+                )
+                assert fs.isfile(fs_join(target, "subfile1"))
+                assert fs.isfile(fs_join(target, "subfile2"))
+                assert not fs.exists(fs_join(target, "nesteddir"))
+                assert not fs.exists(fs_join(target, "subdir"))
 
-            fs.rm(fs.ls(target, detail=False), recursive=True)
-            assert fs.ls(target) == [] if self.supports_empty_directories() else [dummy]
+                fs.rm(
+                    [
+                        fs_join(target, "subfile1"),
+                        fs_join(target, "subfile2"),
+                    ],
+                    recursive=True,
+                )
+                assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
 
     def test_put_glob_to_new_directory(
         self, fs, fs_join, fs_target, local_join, local_bulk_operations_scenario_0
@@ -253,11 +325,6 @@ class AbstractPutTests:
 
         target = fs_target
         fs.mkdir(target)
-        if not self.supports_empty_directories():
-            # Force target directory to exist by adding a dummy file
-            dummy = fs_join(target, "dummy")
-            fs.touch(dummy)
-        assert fs.isdir(target)
 
         for target_slash in [False, True]:
             t = fs_join(target, "newdir")
@@ -278,29 +345,81 @@ class AbstractPutTests:
             assert not fs.exists(fs_join(target, "newdir"))
 
             # With recursive
-            fs.put(local_join(source, "subdir", "*"), t, recursive=True)
-            assert fs.isdir(fs_join(target, "newdir"))
-            assert fs.isfile(fs_join(target, "newdir", "subfile1"))
-            assert fs.isfile(fs_join(target, "newdir", "subfile2"))
-            assert fs.isdir(fs_join(target, "newdir", "nesteddir"))
-            assert fs.isfile(fs_join(target, "newdir", "nesteddir", "nestedfile"))
-            assert not fs.exists(fs_join(target, "subdir"))
-            assert not fs.exists(fs_join(target, "newdir", "subdir"))
+            for glob, recursive in zip(["*", "**"], [True, False]):
+                fs.put(local_join(source, "subdir", glob), t, recursive=recursive)
+                assert fs.isdir(fs_join(target, "newdir"))
+                assert fs.isfile(fs_join(target, "newdir", "subfile1"))
+                assert fs.isfile(fs_join(target, "newdir", "subfile2"))
+                assert fs.isdir(fs_join(target, "newdir", "nesteddir"))
+                assert fs.isfile(fs_join(target, "newdir", "nesteddir", "nestedfile"))
+                assert not fs.exists(fs_join(target, "subdir"))
+                assert not fs.exists(fs_join(target, "newdir", "subdir"))
+
+                fs.rm(fs_join(target, "newdir"), recursive=True)
+                assert not fs.exists(fs_join(target, "newdir"))
+
+                # Limit recursive by maxdepth
+                fs.put(
+                    local_join(source, "subdir", glob),
+                    t,
+                    recursive=recursive,
+                    maxdepth=1,
+                )
+                assert fs.isdir(fs_join(target, "newdir"))
+                assert fs.isfile(fs_join(target, "newdir", "subfile1"))
+                assert fs.isfile(fs_join(target, "newdir", "subfile2"))
+                assert not fs.exists(fs_join(target, "newdir", "nesteddir"))
+                assert not fs.exists(fs_join(target, "subdir"))
+                assert not fs.exists(fs_join(target, "newdir", "subdir"))
 
-            fs.rm(fs_join(target, "newdir"), recursive=True)
-            assert not fs.exists(fs_join(target, "newdir"))
+                fs.rm(fs_join(target, "newdir"), recursive=True)
+                assert not fs.exists(fs_join(target, "newdir"))
 
-            # Limit recursive by maxdepth
-            fs.put(local_join(source, "subdir", "*"), t, recursive=True, maxdepth=1)
-            assert fs.isdir(fs_join(target, "newdir"))
-            assert fs.isfile(fs_join(target, "newdir", "subfile1"))
-            assert fs.isfile(fs_join(target, "newdir", "subfile2"))
-            assert not fs.exists(fs_join(target, "newdir", "nesteddir"))
-            assert not fs.exists(fs_join(target, "subdir"))
-            assert not fs.exists(fs_join(target, "newdir", "subdir"))
+    @pytest.mark.parametrize(
+        GLOB_EDGE_CASES_TESTS["argnames"],
+        GLOB_EDGE_CASES_TESTS["argvalues"],
+    )
+    def test_put_glob_edge_cases(
+        self,
+        path,
+        recursive,
+        maxdepth,
+        expected,
+        fs,
+        fs_join,
+        fs_target,
+        local_glob_edge_cases_files,
+        local_join,
+        fs_sanitize_path,
+    ):
+        # Copy scenario 1g
+        source = local_glob_edge_cases_files
 
-            fs.rm(fs_join(target, "newdir"), recursive=True)
-            assert not fs.exists(fs_join(target, "newdir"))
+        target = fs_target
+
+        for new_dir, target_slash in product([True, False], [True, False]):
+            fs.mkdir(target)
+
+            t = fs_join(target, "newdir") if new_dir else target
+            t = t + "/" if target_slash else t
+
+            fs.put(local_join(source, path), t, recursive=recursive, maxdepth=maxdepth)
+
+            output = fs.find(target)
+            if new_dir:
+                prefixed_expected = [
+                    fs_sanitize_path(fs_join(target, "newdir", p)) for p in expected
+                ]
+            else:
+                prefixed_expected = [
+                    fs_sanitize_path(fs_join(target, p)) for p in expected
+                ]
+            assert sorted(output) == sorted(prefixed_expected)
+
+            try:
+                fs.rm(target, recursive=True)
+            except FileNotFoundError:
+                pass
 
     def test_put_list_of_files_to_existing_directory(
         self,
@@ -309,14 +428,14 @@ class AbstractPutTests:
         fs_target,
         local_join,
         local_bulk_operations_scenario_0,
-        fs_path,
+        supports_empty_directories,
     ):
         # Copy scenario 2a
         source = local_bulk_operations_scenario_0
 
         target = fs_target
         fs.mkdir(target)
-        if not self.supports_empty_directories():
+        if not supports_empty_directories:
             # Force target directory to exist by adding a dummy file
             dummy = fs_join(target, "dummy")
             fs.touch(dummy)
@@ -336,8 +455,15 @@ class AbstractPutTests:
             assert fs.isfile(fs_join(target, "file2"))
             assert fs.isfile(fs_join(target, "subfile1"))
 
-            fs.rm(fs.find(target))
-            assert fs.ls(target) == [] if self.supports_empty_directories() else [dummy]
+            fs.rm(
+                [
+                    fs_join(target, "file1"),
+                    fs_join(target, "file2"),
+                    fs_join(target, "subfile1"),
+                ],
+                recursive=True,
+            )
+            assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
 
     def test_put_list_of_files_to_new_directory(
         self, fs, fs_join, fs_target, local_join, local_bulk_operations_scenario_0
@@ -395,3 +521,57 @@ class AbstractPutTests:
             assert fs.isdir(target)
             assert fs.isfile(fs_join(target, "file"))
             assert not fs.exists(fs_join(target, "src"))
+
+    def test_put_directory_without_files_with_same_name_prefix(
+        self,
+        fs,
+        fs_join,
+        fs_target,
+        local_join,
+        local_dir_and_file_with_same_name_prefix,
+        supports_empty_directories,
+    ):
+        # Create the test dirs
+        source = local_dir_and_file_with_same_name_prefix
+        target = fs_target
+
+        # Test without glob
+        fs.put(local_join(source, "subdir"), fs_target, recursive=True)
+
+        assert fs.isfile(fs_join(fs_target, "subfile.txt"))
+        assert not fs.isfile(fs_join(fs_target, "subdir.txt"))
+
+        fs.rm([fs_join(target, "subfile.txt")])
+        if supports_empty_directories:
+            assert fs.ls(target) == []
+        else:
+            assert not fs.exists(target)
+
+        # Test with glob
+        fs.put(local_join(source, "subdir*"), fs_target, recursive=True)
+
+        assert fs.isdir(fs_join(fs_target, "subdir"))
+        assert fs.isfile(fs_join(fs_target, "subdir", "subfile.txt"))
+        assert fs.isfile(fs_join(fs_target, "subdir.txt"))
+
+    def test_copy_with_source_and_destination_as_list(
+        self, fs, fs_target, fs_join, local_join, local_10_files_with_hashed_names
+    ):
+        # Create the test dir
+        source = local_10_files_with_hashed_names
+        target = fs_target
+
+        # Create list of files for source and destination
+        source_files = []
+        destination_files = []
+        for i in range(10):
+            hashed_i = md5(str(i).encode("utf-8")).hexdigest()
+            source_files.append(local_join(source, f"{hashed_i}.txt"))
+            destination_files.append(fs_join(target, f"{hashed_i}.txt"))
+
+        # Copy and assert order was kept
+        fs.put(lpath=source_files, rpath=destination_files)
+
+        for i in range(10):
+            file_content = fs.cat(destination_files[i]).decode("utf-8")
+            assert file_content == str(i)

fsspec/utils.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
 
+import contextlib
 import logging
 import math
 import os
 import pathlib
 import re
 import sys
-from contextlib import contextmanager
+import tempfile
 from functools import partial
 from hashlib import md5
 from importlib.metadata import version
@@ -343,7 +344,7 @@ def common_prefix(paths):
     return "/".join(parts[0][:i])
 
 
-def other_paths(paths, path2, is_dir=None, exists=False, flatten=False):
+def other_paths(paths, path2, exists=False, flatten=False):
     """In bulk file operations, construct a new file tree from a list of files
 
     Parameters
@@ -353,10 +354,6 @@ def other_paths(paths, path2, is_dir=None, exists=False, flatten=False):
     path2: str or list of str
         Root to construct the new list in. If this is already a list of str, we just
         assert it has the right number of elements.
-    is_dir: bool (optional)
-        For the special case where the input in one element, whether to regard the value
-        as the target path, or as a directory to put a file path within. If None, a
-        directory is inferred if the path ends in '/'
     exists: bool (optional)
         For a str destination, it is already exists (and is a dir), files should
         end up inside.
@@ -370,7 +367,6 @@ def other_paths(paths, path2, is_dir=None, exists=False, flatten=False):
     """
 
     if isinstance(path2, str):
-        is_dir = is_dir or path2.endswith("/")
         path2 = path2.rstrip("/")
 
         if flatten:
@@ -481,7 +477,7 @@ def mirror_from(origin_name, methods):
     return wrapper
 
 
-@contextmanager
+@contextlib.contextmanager
 def nullcontext(obj):
     yield obj
 
@@ -556,3 +552,24 @@ def file_size(filelike):
         return filelike.seek(0, 2)
     finally:
         filelike.seek(pos)
+
+
+@contextlib.contextmanager
+def atomic_write(path: str, mode: str = "wb"):
+    """
+    A context manager that opens a temporary file next to `path` and, on exit,
+    replaces `path` with the temporary file, thereby updating `path`
+    atomically.
+    """
+    fd, fn = tempfile.mkstemp(
+        dir=os.path.dirname(path), prefix=os.path.basename(path) + "-"
+    )
+    try:
+        with open(fd, mode) as fp:
+            yield fp
+    except BaseException:
+        with contextlib.suppress(FileNotFoundError):
+            os.unlink(fn)
+        raise
+    else:
+        os.replace(fn, path)

{fsspec-2023.6.0.dist-info → fsspec-2023.9.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fsspec
-Version: 2023.6.0
+Version: 2023.9.1
 Summary: File-system specification
 Home-page: http://github.com/fsspec/filesystem_spec
 Maintainer: Martin Durant

fsspec-2023.9.1.dist-info/RECORD

@@ -0,0 +1,54 @@
+fsspec/__init__.py,sha256=vbKs09bNlgkk-bfKZOzzvAVJ2-cYNvrmN07R48344F4,1800
+fsspec/_version.py,sha256=xzm3AbPA2trvGGqc2MTnWuPLVLxQMDXP482xNuytWYU,500
+fsspec/archive.py,sha256=FSbEj8w26fcCfuQjQZ_GMLQy5-O5M_KrZkrEdsksato,2406
+fsspec/asyn.py,sha256=6djXIMTdRmke1AxcFsw8QXJWrmYflaSUOq4i_NBnS_M,36593
+fsspec/caching.py,sha256=19qWNHl1dCh0zZSRhqFYIO7Qqco_KOW93L2QPWUnzOc,26373
+fsspec/callbacks.py,sha256=qmD1v-WWxWmTmcUkEadq-_F_n3OGp9JYarjupUq_j3o,6358
+fsspec/compression.py,sha256=-A_TjrGys1jSBQ1IPoPWOdE6X8HJHOSUv94rEvBj9_4,4905
+fsspec/config.py,sha256=LF4Zmu1vhJW7Je9Q-cwkRc3xP7Rhyy7Xnwj26Z6sv2g,4279
+fsspec/conftest.py,sha256=fVfx-NLrH_OZS1TIpYNoPzM7efEcMoL62reHOdYeFCA,1245
+fsspec/core.py,sha256=RrybaRFicCV42YkljakksQp9ZkPgOqLE2lpN6UtvblE,21694
+fsspec/dircache.py,sha256=YzogWJrhEastHU7vWz-cJiJ7sdtLXFXhEpInGKd4EcM,2717
+fsspec/exceptions.py,sha256=s5eA2wIwzj-aeV0i_KDXsBaIhJJRKzmMGUGwuBHTnS4,348
+fsspec/fuse.py,sha256=VnXybwERLONVTgqTTi2ZLVwa2_CzORkRPJG3aHZgAEw,10187
+fsspec/generic.py,sha256=DfRoESTne-DejjV_4VwYJlTqFECYikNIf9brwWp9wsU,13269
+fsspec/gui.py,sha256=XM8ni7YxXC4gjK14Uf_b4HrJIh73WOZot9893B_kzf0,13888
+fsspec/mapping.py,sha256=xr0JkYBf-wwzJcrBi7QIi2dyuZKFD6NWo5UVUHa61BU,8166
+fsspec/parquet.py,sha256=i4H3EU3K1Q6jp8sqjFji6a6gKnlOEZufaa7DRNE5X-4,19516
+fsspec/registry.py,sha256=cOxTT6MpRBif2AeW1x3tWsxYvZBHBsxEwYGNADBBxSM,11012
+fsspec/spec.py,sha256=KqH2YhgleKcBE7WMg1W0QOvK8biFICEYIzidQH4TQao,66742
+fsspec/transaction.py,sha256=KzJVfZxQZ1HeXiBbwC7ba3QtHMRy00yyThXZYP-vMQU,2195
+fsspec/utils.py,sha256=8ste5YfMzOx-DEgKo8jAiGnrFWZkpaboarpMlBGzB3Y,17434
+fsspec/implementations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fsspec/implementations/arrow.py,sha256=1d-c5KceQJxm8QXML8fFXHvQx0wstG-tNJNsrgMX_CI,8240
+fsspec/implementations/cache_mapper.py,sha256=nE_sY3vw-jJbeBcAP6NGtacP3jHW_7EcG3yUSf0A-4Y,2502
+fsspec/implementations/cache_metadata.py,sha256=ZvyA7Y3KK-5Ct4E5pELzD6mH_5T03XqaKVT96qYDADU,8576
+fsspec/implementations/cached.py,sha256=ei5j6Ll5NKwWw_XN8L50kGdmIg63jKGXBYl6j51JfFk,27427
+fsspec/implementations/dask.py,sha256=CXZbJzIVOhKV8ILcxuy3bTvcacCueAbyQxmvAkbPkrk,4466
+fsspec/implementations/dbfs.py,sha256=0ndCE2OQqrWv6Y8ETufxOQ9ymIIO2JA_Q82bnilqTaw,14660
+fsspec/implementations/dirfs.py,sha256=8EEgKin5JgFBqzHaKig7ipiFAZJvbChUX_vpC_jagoY,11136
+fsspec/implementations/ftp.py,sha256=4oAragG80N75O78vVBWVIE1bPB1SGPnw_c7jFNOljsk,11463
+fsspec/implementations/git.py,sha256=Sn96xSjXAl1aA-Gf1DByTd23tiObqv-uAQGc_mryiEw,4034
+fsspec/implementations/github.py,sha256=1d7L22BococztJHKFZvzwvUQZ2cqcBHLhH-4tEDoL0A,7328
+fsspec/implementations/http.py,sha256=bKbA3CiXeyeQGIBPZZVon5IxR5QmpHjWaOmU-jlj7MA,30134
+fsspec/implementations/http_sync.py,sha256=mWHICWqhAqX-WSfdQeWKY5xfhekkVlx3qEl9bY1Y_yA,28555
+fsspec/implementations/jupyter.py,sha256=maOaSOcu3lXI45KCfS3KWkVcM2EZJJjNSICQCXupLK0,3816
+fsspec/implementations/libarchive.py,sha256=lqvLmqG_pSEhkirTEsk1guwtU9_WZ-eOwzzBrPFz84U,7248
+fsspec/implementations/local.py,sha256=dXnZgjjc4wz5ndIRWREh_DzwY_m5qWhPXFFlRhHdWt8,13146
+fsspec/implementations/memory.py,sha256=rtUWe5ooaSs0AWegpZ5DMdkcshGu9-GEQPwavbv1YE0,9741
+fsspec/implementations/reference.py,sha256=3rFxJjLaybO2d7hK8G9K3z2wze9hihLO_dWpTp5ewUs,40765
+fsspec/implementations/sftp.py,sha256=ZsFx4XlyMOx2fT57Pz-_fEz5qLfdPD4ljS3ihuDquAo,5570
+fsspec/implementations/smb.py,sha256=1JeZb_34iqgefEBiJwloa991-4gOKIHxkpS0g6wX43w,10633
+fsspec/implementations/tar.py,sha256=5ZpUp4E3SYbqrwAX2ezvZJqUoZO74Pjb9FpF8o1YBGs,4071
+fsspec/implementations/webhdfs.py,sha256=kJ_gya30beO5fEwlNi8G8CyuZJpfIQ1oe1jOxgF6RjQ,15391
+fsspec/implementations/zip.py,sha256=rQHoOCtT1-Xx3AvNFn5iJ9UVF7Wyiv9wj5MUTIks_nw,4216
+fsspec/tests/abstract/__init__.py,sha256=i1wcFixV6QhOwdoB24c8oXjzobISNqiKVz9kl2DvAY8,10028
+fsspec/tests/abstract/common.py,sha256=X1ijH_pdMc9uVpZtgGj1P-2Zj9VIY-Y0tG3u1vTGcpE,4963
+fsspec/tests/abstract/copy.py,sha256=nyCp1Q9apHzti2_UPDh3HzVhRmV7dciD-3dq-wM7JuU,19643
+fsspec/tests/abstract/get.py,sha256=vNR4HztvTR7Cj56AMo7_tx7TeYz1Jgr_2Wb8Lv-UiBY,20755
+fsspec/tests/abstract/put.py,sha256=hEf-yuMWBOT7B6eWcck3tMyJWzdVXtxkY-O6LUt1KAE,20877
+fsspec-2023.9.1.dist-info/LICENSE,sha256=LcNUls5TpzB5FcAIqESq1T53K0mzTN0ARFBnaRQH7JQ,1513
+fsspec-2023.9.1.dist-info/METADATA,sha256=_OX1UMDXGpI_wzg2avUBO3X-AJq5HR_Y0Cz1CQJManU,6710
+fsspec-2023.9.1.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+fsspec-2023.9.1.dist-info/top_level.txt,sha256=blt2pDrQDwN3Gklcw13CSPLQRd6aaOgJ8AxqrW395MI,7
+fsspec-2023.9.1.dist-info/RECORD,,

fsspec-2023.6.0.dist-info/RECORD

@@ -1,51 +0,0 @@
-fsspec/__init__.py,sha256=vbKs09bNlgkk-bfKZOzzvAVJ2-cYNvrmN07R48344F4,1800
-fsspec/_version.py,sha256=NH6Y4s5Yi4eBruHt22MKbm1HyvY1UF6vdxcCMqS-pyA,500
-fsspec/archive.py,sha256=FSbEj8w26fcCfuQjQZ_GMLQy5-O5M_KrZkrEdsksato,2406
-fsspec/asyn.py,sha256=UerJX18MeZPub5hnYm8KrTPC3nX40-fnZ4bQ2yjTvKw,33978
-fsspec/caching.py,sha256=17xqzc46i0YS_Moyu4JySEoge9TAbzJiLjhK_ieeO3A,26379
-fsspec/callbacks.py,sha256=qmD1v-WWxWmTmcUkEadq-_F_n3OGp9JYarjupUq_j3o,6358
-fsspec/compression.py,sha256=wvC1jmsmo6C6zZiStfBkaTaFBAABMHr0wgJ6WWjavPM,4856
-fsspec/config.py,sha256=LF4Zmu1vhJW7Je9Q-cwkRc3xP7Rhyy7Xnwj26Z6sv2g,4279
-fsspec/conftest.py,sha256=fVfx-NLrH_OZS1TIpYNoPzM7efEcMoL62reHOdYeFCA,1245
-fsspec/core.py,sha256=fKaEhCUAUiA4EgpB4rRXB4wBCmhG4_FGlkWcjkYa5nE,21578
-fsspec/dircache.py,sha256=YzogWJrhEastHU7vWz-cJiJ7sdtLXFXhEpInGKd4EcM,2717
-fsspec/exceptions.py,sha256=s5eA2wIwzj-aeV0i_KDXsBaIhJJRKzmMGUGwuBHTnS4,348
-fsspec/fuse.py,sha256=VnXybwERLONVTgqTTi2ZLVwa2_CzORkRPJG3aHZgAEw,10187
-fsspec/generic.py,sha256=TXcN_hSgZkYS2IGyt-QVSIw_unJkFtReuaBrgOCbFko,10211
-fsspec/gui.py,sha256=b06FSpOgMrSe00dHZr7oBrY5nmL_3QOhrHimLQzfCfU,13860
-fsspec/mapping.py,sha256=tWBRfnQTxXdX4r0j9CDREd3ZkEu7EPRvwRMMvVKE5ig,7879
-fsspec/parquet.py,sha256=i4H3EU3K1Q6jp8sqjFji6a6gKnlOEZufaa7DRNE5X-4,19516
-fsspec/registry.py,sha256=b8r-wlESPPfV-yFxkBHW_n-kvHWuYG5-0swJS4v6lCE,10255
-fsspec/spec.py,sha256=LQ440aSvDovaWsVMIn2JkklZbCAKxKiF4O_NKbAq9SQ,63999
-fsspec/transaction.py,sha256=KzJVfZxQZ1HeXiBbwC7ba3QtHMRy00yyThXZYP-vMQU,2195
-fsspec/utils.py,sha256=np10Ju6YQ-67mpcFlhssQaL5r1ACeKsCcisk_14QGfQ,17155
-fsspec/implementations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fsspec/implementations/arrow.py,sha256=1d-c5KceQJxm8QXML8fFXHvQx0wstG-tNJNsrgMX_CI,8240
-fsspec/implementations/cached.py,sha256=kjva-cnkPwSFzo1FmTeJQiJ5-ZtWYCH2Wk5Ay1SOfJU,30534
-fsspec/implementations/dask.py,sha256=CXZbJzIVOhKV8ILcxuy3bTvcacCueAbyQxmvAkbPkrk,4466
-fsspec/implementations/dbfs.py,sha256=0ndCE2OQqrWv6Y8ETufxOQ9ymIIO2JA_Q82bnilqTaw,14660
-fsspec/implementations/dirfs.py,sha256=GRplS-Dh6ETJQHSrEFuU3s72JR-JIwWyszu1SrCk8wI,11092
-fsspec/implementations/ftp.py,sha256=4oAragG80N75O78vVBWVIE1bPB1SGPnw_c7jFNOljsk,11463
-fsspec/implementations/git.py,sha256=Sn96xSjXAl1aA-Gf1DByTd23tiObqv-uAQGc_mryiEw,4034
-fsspec/implementations/github.py,sha256=1d7L22BococztJHKFZvzwvUQZ2cqcBHLhH-4tEDoL0A,7328
-fsspec/implementations/http.py,sha256=GttNyetwvL9cFJa5616ZuGwYzqKenfbdZw7xk6qYqEw,29225
-fsspec/implementations/http_sync.py,sha256=mWHICWqhAqX-WSfdQeWKY5xfhekkVlx3qEl9bY1Y_yA,28555
-fsspec/implementations/jupyter.py,sha256=maOaSOcu3lXI45KCfS3KWkVcM2EZJJjNSICQCXupLK0,3816
-fsspec/implementations/libarchive.py,sha256=lqvLmqG_pSEhkirTEsk1guwtU9_WZ-eOwzzBrPFz84U,7248
-fsspec/implementations/local.py,sha256=4h6C4H6vnAQ4hVJKjjbgEDT_lEUZaTkpmjaUz0RDGCc,13797
-fsspec/implementations/memory.py,sha256=je-2VUT98PV9DRgeHZo1wtTMY2TieKLWvP3n_mCoMfM,9703
-fsspec/implementations/reference.py,sha256=hZW68dAxHjutxoTrbpvak4WQp2xq3-v79qbEm6WrKKM,40766
-fsspec/implementations/sftp.py,sha256=yYD2niFPv9dFnnSyn0Wcp3qklT_wYO2b09zISxygLOc,5464
-fsspec/implementations/smb.py,sha256=DmiwQL7sg1RXM8ko9BqGaJjVrSDxmhBj9RNPJZt-SBs,10023
-fsspec/implementations/tar.py,sha256=5ZpUp4E3SYbqrwAX2ezvZJqUoZO74Pjb9FpF8o1YBGs,4071
-fsspec/implementations/webhdfs.py,sha256=kJ_gya30beO5fEwlNi8G8CyuZJpfIQ1oe1jOxgF6RjQ,15391
-fsspec/implementations/zip.py,sha256=rQHoOCtT1-Xx3AvNFn5iJ9UVF7Wyiv9wj5MUTIks_nw,4216
-fsspec/tests/abstract/__init__.py,sha256=WnY2HJC3dKWpuXEmyzBQyA2QnfaU-HXpK5jT9kuXxDQ,4702
-fsspec/tests/abstract/copy.py,sha256=HB-mApp4ye34IeswDCkM8alcXQd63wtif6Vgj30Gcrw,13844
-fsspec/tests/abstract/get.py,sha256=EyclZXxZNWo_IpZlDrrLg_GTkSGYvIQPWI9DofSVQDk,12310
-fsspec/tests/abstract/put.py,sha256=Sg4Go5mI3rB4HC43s--yERnhZ3v5ezw9bP93ODcMuw0,15792
-fsspec-2023.6.0.dist-info/LICENSE,sha256=LcNUls5TpzB5FcAIqESq1T53K0mzTN0ARFBnaRQH7JQ,1513
-fsspec-2023.6.0.dist-info/METADATA,sha256=jXoTGDuStQuJANkFAWuqOr_UQBDD0_zcWdHpLkz1OFk,6710
-fsspec-2023.6.0.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-fsspec-2023.6.0.dist-info/top_level.txt,sha256=blt2pDrQDwN3Gklcw13CSPLQRd6aaOgJ8AxqrW395MI,7
-fsspec-2023.6.0.dist-info/RECORD,,