fsspec 2023.10.0__py3-none-any.whl → 2024.2.0__py3-none-any.whl

fsspec/parquet.py

@@ -131,10 +131,8 @@ def open_parquet_file(
         cache_type="parts",
         cache_options={
             **options,
-            **{
-                "data": data.get(fn, {}),
-                "strict": strict,
-            },
+            "data": data.get(fn, {}),
+            "strict": strict,
         },
         **kwargs,
     )
@@ -338,7 +336,7 @@ def _transfer_ranges(fs, blocks, paths, starts, ends):
 
 def _add_header_magic(data):
     # Add b"PAR1" to file headers
-    for i, path in enumerate(list(data.keys())):
+    for path in list(data.keys()):
         add_magic = True
         for k in data[path].keys():
             if k[0] == 0 and k[1] >= 4:

fsspec/registry.py

@@ -57,9 +57,10 @@ def register_implementation(name, cls, clobber=False, errtxt=None):
             _registry[name] = cls
 
 
-# protocols mapped to the class which implements them. This dict can
+# protocols mapped to the class which implements them. This dict can be
 # updated with register_implementation
 known_implementations = {
+    "data": {"class": "fsspec.implementations.data.DataFileSystem"},
     "file": {"class": "fsspec.implementations.local.LocalFileSystem"},
     "local": {"class": "fsspec.implementations.local.LocalFileSystem"},
     "memory": {"class": "fsspec.implementations.memory.MemoryFileSystem"},

fsspec/spec.py

@@ -11,12 +11,13 @@ from glob import has_magic
 from hashlib import sha256
 from typing import ClassVar
 
-from .callbacks import _DEFAULT_CALLBACK
+from .callbacks import DEFAULT_CALLBACK
 from .config import apply_config, conf
 from .dircache import DirCache
 from .transaction import Transaction
 from .utils import (
     _unstrip_protocol,
+    glob_translate,
     isfilelike,
     other_paths,
     read_block,
@@ -109,6 +110,7 @@ class AbstractFileSystem(metaclass=_Cached):
     async_impl = False
     mirror_sync_methods = False
     root_marker = ""  # For some FSs, may require leading '/' or other character
+    transaction_type = Transaction
 
     #: Extra *class attributes* that should be considered when hashing.
     _extra_tokenize_attributes = ()
@@ -235,20 +237,20 @@ class AbstractFileSystem(metaclass=_Cached):
         for the normal and exception cases.
         """
         if self._transaction is None:
-            self._transaction = Transaction(self)
+            self._transaction = self.transaction_type(self)
         return self._transaction
 
     def start_transaction(self):
         """Begin write transaction for deferring files, non-context version"""
         self._intrans = True
-        self._transaction = Transaction(self)
+        self._transaction = self.transaction_type(self)
         return self.transaction
 
     def end_transaction(self):
         """Finish write transaction, non-context version"""
         self.transaction.complete()
         self._transaction = None
-        # The invalid cache must be cleared after the transcation is completed.
+        # The invalid cache must be cleared after the transaction is completed.
         for path in self._invalidated_caches_in_transaction:
             self.invalidate_cache(path)
         self._invalidated_caches_in_transaction.clear()
@@ -551,10 +553,6 @@ class AbstractFileSystem(metaclass=_Cached):
 
         The `maxdepth` option is applied on the first `**` found in the path.
 
-        Search path names that contain embedded characters special to this
-        implementation of glob may not produce expected results;
-        e.g., ``foo/bar/*starredfilename*``.
-
         kwargs are passed to ``ls``.
         """
         if maxdepth is not None and maxdepth < 1:
@@ -562,8 +560,12 @@ class AbstractFileSystem(metaclass=_Cached):
 
         import re
 
-        ends = path.endswith("/")
+        seps = (os.path.sep, os.path.altsep) if os.path.altsep else (os.path.sep,)
+        ends_with_sep = path.endswith(seps)  # _strip_protocol strips trailing slash
         path = self._strip_protocol(path)
+        append_slash_to_dirname = ends_with_sep or path.endswith(
+            tuple(sep + "**" for sep in seps)
+        )
         idx_star = path.find("*") if path.find("*") >= 0 else len(path)
         idx_qmark = path.find("?") if path.find("?") >= 0 else len(path)
         idx_brace = path.find("[") if path.find("[") >= 0 else len(path)
@@ -573,11 +575,11 @@ class AbstractFileSystem(metaclass=_Cached):
         detail = kwargs.pop("detail", False)
 
         if not has_magic(path):
-            if self.exists(path):
+            if self.exists(path, **kwargs):
                 if not detail:
                     return [path]
                 else:
-                    return {path: self.info(path)}
+                    return {path: self.info(path, **kwargs)}
             else:
                 if not detail:
                     return []  # glob of non-existent returns empty
@@ -600,47 +602,22 @@ class AbstractFileSystem(metaclass=_Cached):
                 depth = None
 
         allpaths = self.find(root, maxdepth=depth, withdirs=True, detail=True, **kwargs)
-        # Escape characters special to python regex, leaving our supported
-        # special characters in place.
-        # See https://www.gnu.org/software/bash/manual/html_node/Pattern-Matching.html
-        # for shell globbing details.
-        pattern = (
-            "^"
-            + (
-                path.replace("\\", r"\\")
-                .replace(".", r"\.")
-                .replace("+", r"\+")
-                .replace("//", "/")
-                .replace("(", r"\(")
-                .replace(")", r"\)")
-                .replace("|", r"\|")
-                .replace("^", r"\^")
-                .replace("$", r"\$")
-                .replace("{", r"\{")
-                .replace("}", r"\}")
-                .rstrip("/")
-                .replace("?", ".")
-            )
-            + "$"
-        )
-        pattern = re.sub("/[*]{2}", "=SLASH_DOUBLE_STARS=", pattern)
-        pattern = re.sub("[*]{2}/?", "=DOUBLE_STARS=", pattern)
-        pattern = re.sub("[*]", "[^/]*", pattern)
-        pattern = re.sub("=SLASH_DOUBLE_STARS=", "(|/.*)", pattern)
-        pattern = re.sub("=DOUBLE_STARS=", ".*", pattern)
+
+        pattern = glob_translate(path + ("/" if ends_with_sep else ""))
         pattern = re.compile(pattern)
 
         out = {
-            p: allpaths[p]
-            for p in sorted(allpaths)
-            if pattern.match(p.replace("//", "/").rstrip("/"))
+            p: info
+            for p, info in sorted(allpaths.items())
+            if pattern.match(
+                (
+                    p + "/"
+                    if append_slash_to_dirname and info["type"] == "directory"
+                    else p
+                )
+            )
         }
 
-        # Return directories only when the glob end by a slash
-        # This is needed for posix glob compliance
-        if ends:
-            out = {k: v for k, v in out.items() if v["type"] == "directory"}
-
         if detail:
             return out
         else:
@@ -828,6 +805,16 @@ class AbstractFileSystem(metaclass=_Cached):
     def cat_ranges(
         self, paths, starts, ends, max_gap=None, on_error="return", **kwargs
     ):
+        """Get the contents of byte ranges from one or more files
+
+        Parameters
+        ----------
+        paths: list
+            A list of of filepaths on this filesystems
+        starts, ends: int or list
+            Bytes limits of the read. If using a single int, the same value will be
+            used to read all the specified files.
+        """
         if max_gap is not None:
             raise NotImplementedError
         if not isinstance(paths, list):
@@ -835,7 +822,7 @@ class AbstractFileSystem(metaclass=_Cached):
         if not isinstance(starts, list):
             starts = [starts] * len(paths)
         if not isinstance(ends, list):
-            ends = [starts] * len(paths)
+            ends = [ends] * len(paths)
         if len(starts) != len(paths) or len(ends) != len(paths):
             raise ValueError
         out = []
@@ -889,9 +876,7 @@ class AbstractFileSystem(metaclass=_Cached):
         else:
             return self.cat_file(paths[0], **kwargs)
 
-    def get_file(
-        self, rpath, lpath, callback=_DEFAULT_CALLBACK, outfile=None, **kwargs
-    ):
+    def get_file(self, rpath, lpath, callback=DEFAULT_CALLBACK, outfile=None, **kwargs):
         """Copy single remote file to local"""
         from .implementations.local import LocalFileSystem
 
@@ -901,7 +886,8 @@ class AbstractFileSystem(metaclass=_Cached):
             os.makedirs(lpath, exist_ok=True)
             return None
 
-        LocalFileSystem(auto_mkdir=True).makedirs(self._parent(lpath), exist_ok=True)
+        fs = LocalFileSystem(auto_mkdir=True)
+        fs.makedirs(fs._parent(lpath), exist_ok=True)
 
         with self.open(rpath, "rb", **kwargs) as f1:
             if outfile is None:
@@ -925,7 +911,7 @@ class AbstractFileSystem(metaclass=_Cached):
         rpath,
         lpath,
         recursive=False,
-        callback=_DEFAULT_CALLBACK,
+        callback=DEFAULT_CALLBACK,
         maxdepth=None,
         **kwargs,
     ):
@@ -979,10 +965,10 @@ class AbstractFileSystem(metaclass=_Cached):
 
         callback.set_size(len(lpaths))
         for lpath, rpath in callback.wrap(zip(lpaths, rpaths)):
-            callback.branch(rpath, lpath, kwargs)
-            self.get_file(rpath, lpath, **kwargs)
+            with callback.branched(rpath, lpath) as child:
+                self.get_file(rpath, lpath, callback=child, **kwargs)
 
-    def put_file(self, lpath, rpath, callback=_DEFAULT_CALLBACK, **kwargs):
+    def put_file(self, lpath, rpath, callback=DEFAULT_CALLBACK, **kwargs):
         """Copy single file to remote"""
         if os.path.isdir(lpath):
             self.makedirs(rpath, exist_ok=True)
@@ -1007,7 +993,7 @@ class AbstractFileSystem(metaclass=_Cached):
         lpath,
         rpath,
         recursive=False,
-        callback=_DEFAULT_CALLBACK,
+        callback=DEFAULT_CALLBACK,
         maxdepth=None,
         **kwargs,
     ):
@@ -1065,8 +1051,8 @@ class AbstractFileSystem(metaclass=_Cached):
 
         callback.set_size(len(rpaths))
         for lpath, rpath in callback.wrap(zip(lpaths, rpaths)):
-            callback.branch(lpath, rpath, kwargs)
-            self.put_file(lpath, rpath, **kwargs)
+            with callback.branched(lpath, rpath) as child:
+                self.put_file(lpath, rpath, callback=child, **kwargs)
 
     def head(self, path, size=1024):
         """Get the first ``size`` bytes from file"""
@@ -1146,7 +1132,7 @@ class AbstractFileSystem(metaclass=_Cached):
         if maxdepth is not None and maxdepth < 1:
             raise ValueError("maxdepth must be at least 1")
 
-        if isinstance(path, str):
+        if isinstance(path, (str, os.PathLike)):
             out = self.expand_path([path], recursive, maxdepth)
         else:
             out = set()
@@ -1412,7 +1398,9 @@ class AbstractFileSystem(metaclass=_Cached):
         )
         return json.dumps(
             dict(
-                **{"cls": cls, "protocol": proto, "args": self.storage_args},
+                cls=cls,
+                protocol=proto,
+                args=self.storage_args,
                 **self.storage_options,
             )
         )
@@ -1703,6 +1691,8 @@ class AbstractBufferedFile(io.IOBase):
 
     def __eq__(self, other):
         """Files are equal if they have the same checksum, only in read mode"""
+        if self is other:
+            return True
         return self.mode == "rb" and other.mode == "rb" and hash(self) == hash(other)
 
     def commit(self):

fsspec/tests/abstract/common.py

@@ -107,9 +107,9 @@ GLOB_EDGE_CASES_TESTS = {
                 "subdir1/subfile2",
             ],
         ),
-        ("**1", False, None, ["file1", "subdir0/subfile1", "subdir1/subfile1"]),
+        ("**/*1", False, None, ["file1", "subdir0/subfile1", "subdir1/subfile1"]),
         (
-            "**1",
+            "**/*1",
             True,
             None,
             [
@@ -120,14 +120,14 @@ GLOB_EDGE_CASES_TESTS = {
                 "subdir1/nesteddir/nestedfile",
             ],
         ),
-        ("**1", True, 1, ["file1"]),
+        ("**/*1", True, 1, ["file1"]),
         (
-            "**1",
+            "**/*1",
             True,
             2,
             ["file1", "subdir0/subfile1", "subdir1/subfile1", "subdir1/subfile2"],
         ),
-        ("**1", False, 2, ["file1", "subdir0/subfile1", "subdir1/subfile1"]),
+        ("**/*1", False, 2, ["file1", "subdir0/subfile1", "subdir1/subfile1"]),
         ("**/subdir0", False, None, []),
         ("**/subdir0", True, None, ["subfile1", "subfile2", "nesteddir/nestedfile"]),
         ("**/subdir0/nested*", False, 2, []),

fsspec/tests/abstract/copy.py

@@ -128,7 +128,9 @@ class AbstractCopyTests:
 
             # Without recursive does nothing
             fs.cp(s, t)
-            assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
+            assert fs.ls(target, detail=False) == (
+                [] if supports_empty_directories else [dummy]
+            )
 
             # With recursive
             fs.cp(s, t, recursive=True)
@@ -155,7 +157,9 @@ class AbstractCopyTests:
                 assert fs.isfile(fs_join(target, "subdir", "nesteddir", "nestedfile"))
 
                 fs.rm(fs_join(target, "subdir"), recursive=True)
-            assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
+            assert fs.ls(target, detail=False) == (
+                [] if supports_empty_directories else [dummy]
+            )
 
             # Limit recursive by maxdepth
             fs.cp(s, t, recursive=True, maxdepth=1)
@@ -179,7 +183,9 @@ class AbstractCopyTests:
                 assert not fs.exists(fs_join(target, "subdir", "nesteddir"))
 
                 fs.rm(fs_join(target, "subdir"), recursive=True)
-            assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
+            assert fs.ls(target, detail=False) == (
+                [] if supports_empty_directories else [dummy]
+            )
 
     def test_copy_directory_to_new_directory(
         self,
@@ -271,7 +277,9 @@ class AbstractCopyTests:
                 ],
                 recursive=True,
             )
-            assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
+            assert fs.ls(target, detail=False) == (
+                [] if supports_empty_directories else [dummy]
+            )
 
             # With recursive
             for glob, recursive in zip(["*", "**"], [True, False]):
@@ -290,7 +298,9 @@ class AbstractCopyTests:
                     ],
                     recursive=True,
                 )
-                assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
+                assert fs.ls(target, detail=False) == (
+                    [] if supports_empty_directories else [dummy]
+                )
 
                 # Limit recursive by maxdepth
                 fs.cp(
@@ -308,7 +318,9 @@ class AbstractCopyTests:
                     ],
                     recursive=True,
                 )
-                assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
+                assert fs.ls(target, detail=False) == (
+                    [] if supports_empty_directories else [dummy]
+                )
 
     def test_copy_glob_to_new_directory(
         self, fs, fs_join, fs_bulk_operations_scenario_0, fs_target
@@ -451,7 +463,9 @@ class AbstractCopyTests:
                 ],
                 recursive=True,
             )
-            assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
+            assert fs.ls(target, detail=False) == (
+                [] if supports_empty_directories else [dummy]
+            )
 
     def test_copy_list_of_files_to_new_directory(
         self, fs, fs_join, fs_bulk_operations_scenario_0, fs_target

fsspec/tests/abstract/put.py

@@ -131,7 +131,9 @@ class AbstractPutTests:
 
             # Without recursive does nothing
             fs.put(s, t)
-            assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
+            assert fs.ls(target, detail=False) == (
+                [] if supports_empty_directories else [dummy]
+            )
 
             # With recursive
             fs.put(s, t, recursive=True)
@@ -158,7 +160,9 @@ class AbstractPutTests:
                 assert fs.isfile(fs_join(target, "subdir", "nesteddir", "nestedfile"))
 
                 fs.rm(fs_join(target, "subdir"), recursive=True)
-            assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
+            assert fs.ls(target, detail=False) == (
+                [] if supports_empty_directories else [dummy]
+            )
 
             # Limit recursive by maxdepth
             fs.put(s, t, recursive=True, maxdepth=1)
@@ -182,7 +186,9 @@ class AbstractPutTests:
                 assert not fs.exists(fs_join(target, "subdir", "nesteddir"))
 
                 fs.rm(fs_join(target, "subdir"), recursive=True)
-            assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
+            assert fs.ls(target, detail=False) == (
+                [] if supports_empty_directories else [dummy]
+            )
 
     def test_put_directory_to_new_directory(
         self,
@@ -275,7 +281,9 @@ class AbstractPutTests:
                 ],
                 recursive=True,
             )
-            assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
+            assert fs.ls(target, detail=False) == (
+                [] if supports_empty_directories else [dummy]
+            )
 
             # With recursive
             for glob, recursive in zip(["*", "**"], [True, False]):
@@ -294,7 +302,9 @@ class AbstractPutTests:
                     ],
                     recursive=True,
                 )
-                assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
+                assert fs.ls(target, detail=False) == (
+                    [] if supports_empty_directories else [dummy]
+                )
 
                 # Limit recursive by maxdepth
                 fs.put(
@@ -315,7 +325,9 @@ class AbstractPutTests:
                     ],
                     recursive=True,
                 )
-                assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
+                assert fs.ls(target, detail=False) == (
+                    [] 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
@@ -463,7 +475,9 @@ class AbstractPutTests:
                 ],
                 recursive=True,
             )
-            assert fs.ls(target) == ([] if supports_empty_directories else [dummy])
+            assert fs.ls(target, detail=False) == (
+                [] 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

fsspec/transaction.py

@@ -1,3 +1,6 @@
+from collections import deque
+
+
 class Transaction:
     """Filesystem transaction write context
 
@@ -13,10 +16,11 @@ class Transaction:
         fs: FileSystem instance
         """
         self.fs = fs
-        self.files = []
+        self.files = deque()
 
     def __enter__(self):
         self.start()
+        return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         """End transaction and commit, if exit is not due to exception"""
@@ -27,17 +31,17 @@ class Transaction:
 
     def start(self):
         """Start a transaction on this FileSystem"""
-        self.files = []  # clean up after previous failed completions
+        self.files = deque()  # clean up after previous failed completions
         self.fs._intrans = True
 
     def complete(self, commit=True):
         """Finish transaction: commit or discard all deferred files"""
-        for f in self.files:
+        while self.files:
+            f = self.files.popleft()
             if commit:
                 f.commit()
             else:
                 f.discard()
-        self.files = []
         self.fs._intrans = False
 
 

fsspec/utils.py

@@ -320,7 +320,7 @@ def tokenize(*args: Any, **kwargs: Any) -> str:
         h = md5(str(args).encode())
     except ValueError:
         # FIPS systems: https://github.com/fsspec/filesystem_spec/issues/380
-        h = md5(str(args).encode(), usedforsecurity=False)  # type: ignore[call-arg]
+        h = md5(str(args).encode(), usedforsecurity=False)
     return h.hexdigest()
 
 
@@ -436,6 +436,7 @@ def isfilelike(f: Any) -> TypeGuard[IO[bytes]]:
 
 
 def get_protocol(url: str) -> str:
+    url = stringify_path(url)
     parts = re.split(r"(\:\:|\://)", url, 1)
     if len(parts) > 1:
         return parts[0]
@@ -627,3 +628,115 @@ def atomic_write(path: str, mode: str = "wb"):
         raise
     else:
         os.replace(fn, path)
+
+
+def _translate(pat, STAR, QUESTION_MARK):
+    # Copied from: https://github.com/python/cpython/pull/106703.
+    res: list[str] = []
+    add = res.append
+    i, n = 0, len(pat)
+    while i < n:
+        c = pat[i]
+        i = i + 1
+        if c == "*":
+            # compress consecutive `*` into one
+            if (not res) or res[-1] is not STAR:
+                add(STAR)
+        elif c == "?":
+            add(QUESTION_MARK)
+        elif c == "[":
+            j = i
+            if j < n and pat[j] == "!":
+                j = j + 1
+            if j < n and pat[j] == "]":
+                j = j + 1
+            while j < n and pat[j] != "]":
+                j = j + 1
+            if j >= n:
+                add("\\[")
+            else:
+                stuff = pat[i:j]
+                if "-" not in stuff:
+                    stuff = stuff.replace("\\", r"\\")
+                else:
+                    chunks = []
+                    k = i + 2 if pat[i] == "!" else i + 1
+                    while True:
+                        k = pat.find("-", k, j)
+                        if k < 0:
+                            break
+                        chunks.append(pat[i:k])
+                        i = k + 1
+                        k = k + 3
+                    chunk = pat[i:j]
+                    if chunk:
+                        chunks.append(chunk)
+                    else:
+                        chunks[-1] += "-"
+                    # Remove empty ranges -- invalid in RE.
+                    for k in range(len(chunks) - 1, 0, -1):
+                        if chunks[k - 1][-1] > chunks[k][0]:
+                            chunks[k - 1] = chunks[k - 1][:-1] + chunks[k][1:]
+                            del chunks[k]
+                    # Escape backslashes and hyphens for set difference (--).
+                    # Hyphens that create ranges shouldn't be escaped.
+                    stuff = "-".join(
+                        s.replace("\\", r"\\").replace("-", r"\-") for s in chunks
+                    )
+                # Escape set operations (&&, ~~ and ||).
+                stuff = re.sub(r"([&~|])", r"\\\1", stuff)
+                i = j + 1
+                if not stuff:
+                    # Empty range: never match.
+                    add("(?!)")
+                elif stuff == "!":
+                    # Negated empty range: match any character.
+                    add(".")
+                else:
+                    if stuff[0] == "!":
+                        stuff = "^" + stuff[1:]
+                    elif stuff[0] in ("^", "["):
+                        stuff = "\\" + stuff
+                    add(f"[{stuff}]")
+        else:
+            add(re.escape(c))
+    assert i == n
+    return res
+
+
+def glob_translate(pat):
+    # Copied from: https://github.com/python/cpython/pull/106703.
+    # The keyword parameters' values are fixed to:
+    # recursive=True, include_hidden=True, seps=None
+    """Translate a pathname with shell wildcards to a regular expression."""
+    if os.path.altsep:
+        seps = os.path.sep + os.path.altsep
+    else:
+        seps = os.path.sep
+    escaped_seps = "".join(map(re.escape, seps))
+    any_sep = f"[{escaped_seps}]" if len(seps) > 1 else escaped_seps
+    not_sep = f"[^{escaped_seps}]"
+    one_last_segment = f"{not_sep}+"
+    one_segment = f"{one_last_segment}{any_sep}"
+    any_segments = f"(?:.+{any_sep})?"
+    any_last_segments = ".*"
+    results = []
+    parts = re.split(any_sep, pat)
+    last_part_idx = len(parts) - 1
+    for idx, part in enumerate(parts):
+        if part == "*":
+            results.append(one_segment if idx < last_part_idx else one_last_segment)
+            continue
+        if part == "**":
+            results.append(any_segments if idx < last_part_idx else any_last_segments)
+            continue
+        elif "**" in part:
+            raise ValueError(
+                "Invalid pattern: '**' can only be an entire path component"
+            )
+        if part:
+            results.extend(_translate(part, f"{not_sep}*", not_sep))
+        if idx < last_part_idx:
+            results.append(any_sep)
+    res = "".join(results)
+    return rf"(?s:{res})\Z"

{fsspec-2023.10.0.dist-info → fsspec-2024.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fsspec
-Version: 2023.10.0
+Version: 2024.2.0
 Summary: File-system specification
 Home-page: https://github.com/fsspec/filesystem_spec
 Maintainer: Martin Durant
@@ -71,7 +71,6 @@ Requires-Dist: panel ; extra == 'gui'
 Provides-Extra: hdfs
 Requires-Dist: pyarrow >=1 ; extra == 'hdfs'
 Provides-Extra: http
-Requires-Dist: requests ; extra == 'http'
 Requires-Dist: aiohttp !=4.0.0a0,!=4.0.0a1 ; extra == 'http'
 Provides-Extra: libarchive
 Requires-Dist: libarchive-c ; extra == 'libarchive'