Fix B905 zip() without an explicit strict= parameter

Author: hugovk

fsspec/archive.py

@@ -61,7 +61,9 @@ def ls(self, path, detail=True, **kwargs):
                 paths[p] = f
             elif all(
                 (a == b)
-                for a, b in zip(path.split("/"), [""] + p.strip("/").split("/"))
+                for a, b in zip(
+                    path.split("/"), [""] + p.strip("/").split("/"), strict=False
+                )
             ):
                 # root directory entry
                 ppath = p.rstrip("/").split("/", 1)[0]

fsspec/asyn.py

@@ -397,7 +397,10 @@ async def _copy(
             )
 
         batch_size = batch_size or self.batch_size
-        coros = [self._cp_file(p1, p2, **kwargs) for p1, p2 in zip(paths1, paths2)]
+        coros = [
+            self._cp_file(p1, p2, **kwargs)
+            for p1, p2 in zip(paths1, paths2, strict=False)
+        ]
         result = await _run_coros_in_chunks(
             coros, batch_size=batch_size, return_exceptions=True, nofiles=True
         )
@@ -469,7 +472,7 @@ async def _cat(
         ):
             return {
                 k: v
-                for k, v in zip(paths, out)
+                for k, v in zip(paths, out, strict=False)
                 if on_error != "omit" or not is_exception(v)
             }
         else:
@@ -509,7 +512,7 @@ async def _cat_ranges(
             raise ValueError
         coros = [
             self._cat_file(p, start=s, end=e, **kwargs)
-            for p, s, e in zip(paths, starts, ends)
+            for p, s, e in zip(paths, starts, ends, strict=False)
         ]
         batch_size = batch_size or self.batch_size
         return await _run_coros_in_chunks(
@@ -577,8 +580,10 @@ async def _put(
             )
 
         is_dir = {l: os.path.isdir(l) for l in lpaths}
-        rdirs = [r for l, r in zip(lpaths, rpaths) if is_dir[l]]
-        file_pairs = [(l, r) for l, r in zip(lpaths, rpaths) if not is_dir[l]]
+        rdirs = [r for l, r in zip(lpaths, rpaths, strict=False) if is_dir[l]]
+        file_pairs = [
+            (l, r) for l, r in zip(lpaths, rpaths, strict=False) if not is_dir[l]
+        ]
 
         await asyncio.gather(*[self._makedirs(d, exist_ok=True) for d in rdirs])
         batch_size = batch_size or self.batch_size
@@ -662,7 +667,7 @@ async def _get(
 
         coros = []
         callback.set_size(len(lpaths))
-        for lpath, rpath in zip(lpaths, rpaths):
+        for lpath, rpath in zip(lpaths, rpaths, strict=False):
             get_file = callback.branch_coro(self._get_file)
             coros.append(get_file(rpath, lpath, **kwargs))
         return await _run_coros_in_chunks(

fsspec/caching.py

@@ -642,7 +642,7 @@ def __init__(
                     offsets.append((start, stop))
                     blocks.append(data.pop((start, stop)))
 
-            self.data = dict(zip(offsets, blocks))
+            self.data = dict(zip(offsets, blocks, strict=False))
         else:
             self.data = {}
 

fsspec/generic.py

@@ -135,7 +135,7 @@ def rsync(
             allfiles[k] = otherfile
     logger.debug(f"{len(allfiles)} files to copy")
     if allfiles:
-        source_files, target_files = zip(*allfiles.items())
+        source_files, target_files = zip(*allfiles.items(), strict=False)
         fs.cp(source_files, target_files, **kwargs)
     logger.debug(f"{len(to_delete)} files to delete")
     if delete_missing and to_delete:
@@ -361,7 +361,7 @@ async def copy_file_op(
                 u2,
                 os.path.join(tempdir, uuid.uuid4().hex),
             )
-            for u1, u2 in zip(url1, url2)
+            for u1, u2 in zip(url1, url2, strict=False)
         ]
         out = await _run_coros_in_chunks(
             coros, batch_size=batch_size, return_exceptions=True

fsspec/implementations/cache_metadata.py

@@ -105,7 +105,9 @@ def check_file(
         perform extra checks to reject possible matches, such as if they are
         too old.
         """
-        for (fn, base, _), cache in zip(self._scan_locations(), self.cached_files):
+        for (fn, base, _), cache in zip(
+            self._scan_locations(), self.cached_files, strict=False
+        ):
             if path not in cache:
                 continue
             detail = cache[path].copy()
@@ -192,7 +194,9 @@ def pop_file(self, path: str) -> str | None:
 
     def save(self) -> None:
         """Save metadata to disk"""
-        for (fn, _, writable), cache in zip(self._scan_locations(), self.cached_files):
+        for (fn, _, writable), cache in zip(
+            self._scan_locations(), self.cached_files, strict=False
+        ):
             if not writable:
                 continue
 

fsspec/implementations/cached.py

@@ -574,12 +574,12 @@ def open_many(self, open_files, **kwargs):
         if self.compression:
             raise NotImplementedError
         details = [self._check_file(sp) for sp in paths]
-        downpath = [p for p, d in zip(paths, details) if not d]
+        downpath = [p for p, d in zip(paths, details, strict=False) if not d]
         downfn0 = [
             os.path.join(self.storage[-1], self._mapper(p))
-            for p, d in zip(paths, details)
+            for p, d in zip(paths, details, strict=False)
         ]  # keep these path names for opening later
-        downfn = [fn for fn, d in zip(downfn0, details) if not d]
+        downfn = [fn for fn, d in zip(downfn0, details, strict=False) if not d]
         if downpath:
             # skip if all files are already cached and up to date
             self.fs.get(downpath, downfn)
@@ -595,7 +595,7 @@ def open_many(self, open_files, **kwargs):
                 }
                 for path in downpath
             ]
-            for path, detail in zip(downpath, newdetail):
+            for path, detail in zip(downpath, newdetail, strict=False):
                 self._metadata.update_file(path, detail)
             self.save_cache()
 
@@ -605,7 +605,7 @@ def firstpart(fn):
 
         return [
             open(firstpart(fn0) if fn0 else fn1, mode=open_files.mode)
-            for fn0, fn1 in zip(details, downfn0)
+            for fn0, fn1 in zip(details, downfn0, strict=False)
         ]
 
     def commit_many(self, open_files):
@@ -670,7 +670,7 @@ def cat(
             self.save_cache()
 
         callback.set_size(len(paths))
-        for p, fn in zip(paths, fns):
+        for p, fn in zip(paths, fns, strict=False):
             with open(fn, "rb") as f:
                 out[p] = f.read()
             callback.relative_update(1)
@@ -886,8 +886,8 @@ def cat_ranges(
     ):
         logger.debug("cat ranges %s", paths)
         lpaths = [self._check_file(p) for p in paths]
-        rpaths = [p for l, p in zip(lpaths, paths) if l is False]
-        lpaths = [l for l, p in zip(lpaths, paths) if l is False]
+        rpaths = [p for l, p in zip(lpaths, paths, strict=False) if l is False]
+        lpaths = [l for l, p in zip(lpaths, paths, strict=False) if l is False]
         self.fs.get(rpaths, lpaths)
         paths = [self._check_file(p) for p in paths]
         return LocalFileSystem().cat_ranges(

fsspec/implementations/reference.py

@@ -76,13 +76,13 @@ def __iter__(self):
 
 class RefsItemsView(collections.abc.ItemsView):
     def __iter__(self):
-        return zip(self._mapping.keys(), self._mapping.values())
+        return zip(self._mapping.keys(), self._mapping.values(), strict=False)
 
 
 def ravel_multi_index(idx, sizes):
     val = 0
     mult = 1
-    for i, s in zip(idx[::-1], sizes[::-1]):
+    for i, s in zip(idx[::-1], sizes[::-1], strict=False):
         val += i * mult
         mult *= s
     return val
@@ -286,7 +286,7 @@ def ls(self, path="", detail=True):
         recs = self._generate_all_records(field)
         recinfo = [
             {"name": name, "type": "file", "size": rec[-1]}
-            for name, rec in zip(keys, recs)
+            for name, rec in zip(keys, recs, strict=False)
             if rec[0]  # filters out path==None, deleted/missing
         ]
         return fileinfo + recinfo
@@ -349,15 +349,16 @@ def _get_chunk_sizes(self, field):
         if field not in self.chunk_sizes:
             zarray = self.zmetadata[f"{field}/.zarray"]
             size_ratio = [
-                math.ceil(s / c) for s, c in zip(zarray["shape"], zarray["chunks"])
+                math.ceil(s / c)
+                for s, c in zip(zarray["shape"], zarray["chunks"], strict=False)
             ]
             self.chunk_sizes[field] = size_ratio or [1]
         return self.chunk_sizes[field]
 
     def _generate_record(self, field, record):
         """The references for a given parquet file of a given field"""
         refs = self.open_refs(field, record)
-        it = iter(zip(*refs.values()))
+        it = iter(zip(*refs.values(), strict=False))
         if len(refs) == 3:
             # All urls
             return (list(t) for t in it)
@@ -878,7 +879,7 @@ def get(self, rpath, lpath, recursive=False, **kwargs):
             data = self.cat([r for r in rpath if not self.isdir(r)])
         else:
             data = self.cat(rpath)
-        for remote, local in zip(rpath, targets):
+        for remote, local in zip(rpath, targets, strict=False):
             if remote in data:
                 fs.pipe_file(local, data[remote])
 
@@ -918,7 +919,7 @@ def cat(self, path, recursive=False, on_error="raise", **kwargs):
             ends2 = []
             paths2 = []
             whole_files = set()
-            for u, s, e, p in zip(urls, starts, ends, valid_paths):
+            for u, s, e, p in zip(urls, starts, ends, valid_paths, strict=False):
                 if isinstance(u, bytes):
                     # data
                     out[p] = u
@@ -930,7 +931,7 @@ def cat(self, path, recursive=False, on_error="raise", **kwargs):
                     starts2.append(s)
                     ends2.append(e)
                     paths2.append(p)
-            for u, s, e, p in zip(urls, starts, ends, valid_paths):
+            for u, s, e, p in zip(urls, starts, ends, valid_paths, strict=False):
                 # second run to account for files that are to be loaded whole
                 if s is not None and u not in whole_files:
                     urls2.append(u)
@@ -950,10 +951,12 @@ def cat(self, path, recursive=False, on_error="raise", **kwargs):
             bytes_out = fs.cat_ranges(new_paths, new_starts, new_ends)
 
             # unbundle from merged bytes - simple approach
-            for u, s, e, p in zip(urls, starts, ends, valid_paths):
+            for u, s, e, p in zip(urls, starts, ends, valid_paths, strict=False):
                 if p in out:
                     continue  # was bytes, already handled
-                for np, ns, ne, b in zip(new_paths, new_starts, new_ends, bytes_out):
+                for np, ns, ne, b in zip(
+                    new_paths, new_starts, new_ends, bytes_out, strict=False
+                ):
                     if np == u and (ns is None or ne is None):
                         if isinstance(b, Exception):
                             out[p] = b
@@ -1061,7 +1064,7 @@ def _process_gen(self, gens):
                 for k, v in gen["dimensions"].items()
             }
             products = (
-                dict(zip(dimension.keys(), values))
+                dict(zip(dimension.keys(), values, strict=False))
                 for values in itertools.product(*dimension.values())
             )
             for pr in products:
@@ -1105,7 +1108,7 @@ def _dircache_from_items(self):
                 subdirs.append(par0)
 
             subdirs.reverse()
-            for parent, child in zip(subdirs, subdirs[1:]):
+            for parent, child in zip(subdirs, subdirs[1:], strict=False):
                 # register newly discovered directories
                 assert child not in self.dircache
                 assert parent in self.dircache

fsspec/implementations/tests/test_archive.py

@@ -322,7 +322,7 @@ def test_walk(self, scenario: ArchiveTestScenario, topdown, prune_nested):
             # prior py3.10 zip() does not support strict=True, we need
             # a manual len check here
             assert len(result) == len(expected)
-            for lhs, rhs in zip(result, expected):
+            for lhs, rhs in zip(result, expected, strict=False):
                 assert lhs[0] == rhs[0]
                 assert sorted(lhs[1]) == sorted(rhs[1])
                 assert sorted(lhs[2]) == sorted(rhs[2])

fsspec/implementations/tests/test_local.py

@@ -172,11 +172,13 @@ def test_urlpath_expand_write():
     """Make sure * is expanded in file paths when writing."""
     _, _, paths = get_fs_token_paths("prefix-*.csv", mode="wb", num=2)
     assert all(
-        p.endswith(pa) for p, pa in zip(paths, ["/prefix-0.csv", "/prefix-1.csv"])
+        p.endswith(pa)
+        for p, pa in zip(paths, ["/prefix-0.csv", "/prefix-1.csv"], strict=False)
     )
     _, _, paths = get_fs_token_paths(["prefix-*.csv"], mode="wb", num=2)
     assert all(
-        p.endswith(pa) for p, pa in zip(paths, ["/prefix-0.csv", "/prefix-1.csv"])
+        p.endswith(pa)
+        for p, pa in zip(paths, ["/prefix-0.csv", "/prefix-1.csv"], strict=False)
     )
     # we can read with multiple masks, but not write
     with pytest.raises(ValueError):
@@ -189,7 +191,7 @@ def test_open_files():
     with filetexts(files, mode="b"):
         myfiles = open_files("./.test.accounts.*")
         assert len(myfiles) == len(files)
-        for lazy_file, data_file in zip(myfiles, sorted(files)):
+        for lazy_file, data_file in zip(myfiles, sorted(files), strict=False):
             with lazy_file as f:
                 x = f.read()
                 assert x == files[data_file]
@@ -291,7 +293,7 @@ def test_pickability_of_lazy_files(tmpdir):
         myfiles = open_files("./.test.accounts.*")
         myfiles2 = cloudpickle.loads(cloudpickle.dumps(myfiles))
 
-        for f, f2 in zip(myfiles, myfiles2):
+        for f, f2 in zip(myfiles, myfiles2, strict=False):
             assert f.path == f2.path
             assert isinstance(f.fs, type(f2.fs))
             with f as f_open, f2 as f2_open:

fsspec/implementations/zip.py

@@ -145,7 +145,7 @@ def find(self, path, maxdepth=None, withdirs=False, detail=False, **kwargs):
 
         def _matching_starts(file_path):
             file_parts = filter(lambda s: bool(s), file_path.split("/"))
-            return all(a == b for a, b in zip(path_parts, file_parts))
+            return all(a == b for a, b in zip(path_parts, file_parts, strict=False))
 
         self._get_dirs()