objpath 0.1.0__tar.gz → 0.1.1__tar.gz

{objpath-0.1.0 → objpath-0.1.1}/CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.1.1] - 2026-10-17
+
+### Added
+
+- **`rm()` and `copy()` take `max_workers`**, the keyword of `pathapi`'s recursive
+  `rm()` and `copy()` (a class runs serially unless it declares `_threadsafe`,
+  which these classes do not). A streamed copy passes it on; the batch delete and the
+  store's own copy call ignore it. Nothing changes for a call that does not give it,
+  and it works with the `pathapi` release that lacks it as long as it is not given.
+
 ## [0.1.0] - 2026-10-14
 
 The first release of `objpath`: the Amazon S3, Google Cloud Storage and Azure Blob
@@ -109,5 +119,6 @@ name `pathlib_next`); the old names below are the ones before the move.
   and emits a `ResourceWarning`; `pathlib-next` closed it, and so uploaded it. What to do:
   close the file, or use `with`.
 
-[Unreleased]: https://github.com/jose-pr/objpath/compare/v0.1.0...HEAD
+[Unreleased]: https://github.com/jose-pr/objpath/compare/v0.1.1...HEAD
+[0.1.1]: https://github.com/jose-pr/objpath/compare/v0.1.0...v0.1.1
 [0.1.0]: https://github.com/jose-pr/objpath/releases/tag/v0.1.0

{objpath-0.1.0 → objpath-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: objpath
-Version: 0.1.0
+Version: 0.1.1
 Summary: pathlib-style paths for S3, Google Cloud Storage and Azure Blob Storage, and the s3:, gs: and az: schemes for uripath
 Project-URL: Homepage, https://github.com/jose-pr/objpath/
 Project-URL: Documentation, https://jose-pr.github.io/objpath/

{objpath-0.1.0 → objpath-0.1.1}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "objpath"
-version = "0.1.0"
+version = "0.1.1"
 authors = [{ name = "Jose A" }]
 description = "pathlib-style paths for S3, Google Cloud Storage and Azure Blob Storage, and the s3:, gs: and az: schemes for uripath"
 readme = "README.md"

{objpath-0.1.0 → objpath-0.1.1}/src/objpath/AGENTS.md

@@ -160,6 +160,9 @@ Reading and writing:
   with that key's path, one error per key. `rm(recursive=True)` of a missing bucket is
   a missing path (`missing_ok`, `ignore_error` decide). There are no symlinks or
   bindings: `follow_symlinks=` and `follow_binds=` are checked and decide nothing.
+  `rm()` and `copy()` take `max_workers=None` (`pathapi`'s keyword, passed on to the
+  generic walks only when given; the batch delete and the store's copy call ignore it,
+  and a path never declares `_threadsafe`).
 - `checksum(algorithm="md5")` (`NativeChecksum`) is the digest the store keeps, read with
   one request and no byte of the content. S3: the plain MD5 that the ETag is for an object
   one request wrote and KMS or a customer key does not encrypt, or the stored full-object

{objpath-0.1.0 → objpath-0.1.1}/src/objpath/_storepath.py

@@ -371,7 +371,10 @@ class ObjectStorePath(TreePath):
         *,
         follow_symlinks=False,
         follow_binds=False,
+        max_workers=None,
     ):
+        """Remove as `Path.rm()` does. `max_workers` is `Path.rm()`'s and is
+        ignored: a recursive removal is the store's batch delete."""
         # An object store holds no symlinks or bindings: the policies are
         # checked and have nothing to decide.
         check_follow("follow_symlinks", follow_symlinks)
@@ -383,6 +386,8 @@ class ObjectStorePath(TreePath):
                 ignore_error=ignore_error,
                 follow_symlinks=follow_symlinks,
                 follow_binds=follow_binds,
+                # Only when given: pathapi 0.1.1 has no such keyword.
+                **({} if max_workers is None else {"max_workers": max_workers}),
             )
 
         def on_error(error, path=None):
@@ -461,7 +466,11 @@ class ObjectStorePath(TreePath):
         ignore_error=None,
         progress=None,
         on_error=None,
+        max_workers=None,
     ):
+        """Copy as `Path.copy()` does, with the store's own copy call for one
+        object of the same store. `max_workers` is `Path.copy()`'s and applies to
+        the streamed copy only; the store's copy call ignores it."""
         # A prefix is copied by walking it; one that holds keys the walk
         # cannot reach is refused up front rather than copied incompletely.
         # That refusal is not a per-child error: `on_error` is never asked.
@@ -486,6 +495,8 @@ class ObjectStorePath(TreePath):
                 ignore_error=ignore_error,
                 progress=progress,
                 **({} if on_error is None else {"on_error": on_error}),
+                # Only when given: pathapi 0.1.1 has no such keyword.
+                **({} if max_workers is None else {"max_workers": max_workers}),
             )
 
     def _store_copy_possible(self, target) -> bool:

{objpath-0.1.0 → objpath-0.1.1}/src/objpath/_uri_store.py

@@ -92,7 +92,10 @@ class ObjectStoreURIPath(DelegatingURIPath):
         *,
         follow_symlinks=False,
         follow_binds=False,
+        max_workers=None,
     ):
+        """Remove as `Path.rm()` does. `max_workers` is `Path.rm()`'s and is
+        ignored: a recursive removal is the store's batch delete."""
         check_follow("follow_symlinks", follow_symlinks)
         check_follow("follow_binds", follow_binds)
         on_error = ignore_error
@@ -110,6 +113,7 @@ class ObjectStoreURIPath(DelegatingURIPath):
                 ignore_error=on_error,
                 follow_symlinks=follow_symlinks,
                 follow_binds=follow_binds,
+                max_workers=max_workers,
             )
 
     def copy(
@@ -123,7 +127,11 @@ class ObjectStoreURIPath(DelegatingURIPath):
         ignore_error=None,
         progress=None,
         on_error=None,
+        max_workers=None,
     ):
+        """Copy as `Path.copy()` does, with the store's own copy call for one
+        object of the same store. `max_workers` is `Path.copy()`'s and applies to
+        the streamed copy only; the store's copy call ignores it."""
         # The core path's walk of a prefix is not used: children are URI paths
         # and are copied through this method, so the refusal of a prefix that
         # holds keys a walk cannot reach is made here, once.
@@ -159,4 +167,6 @@ class ObjectStoreURIPath(DelegatingURIPath):
                 ignore_error=ignore_error,
                 progress=progress,
                 **({} if offering is None else {"on_error": offering}),
+                # Only when given: pathapi 0.1.1 has no such keyword.
+                **({} if max_workers is None else {"max_workers": max_workers}),
             )

{objpath-0.1.0 → objpath-0.1.1}/tests/mutation/mutants.py

@@ -434,3 +434,30 @@ mutant(
     "tests/test_spool_unclosed.py::test_an_unclosed_stream_that_was_not_modified_is_collected_silently",
     "a spooled stream with nothing to upload warns when collected",
 )
+
+mutant(
+    "objpath-store-rm-always-passes-max-workers",
+    "_storepath.py",
+    '                # Only when given: pathapi 0.1.1 has no such keyword.\n                **({} if max_workers is None else {"max_workers": max_workers}),\n            )\n\n        def on_error(',
+    "                max_workers=max_workers,\n            )\n\n        def on_error(",
+    "tests/test_az_fake.py::test_the_generic_calls_get_max_workers_only_when_it_is_given",
+    "rm() hands pathapi a max_workers it was not given, which a release without the keyword refuses",
+)
+
+mutant(
+    "objpath-store-copy-always-passes-max-workers",
+    "_storepath.py",
+    '                # Only when given: pathapi 0.1.1 has no such keyword.\n                **({} if max_workers is None else {"max_workers": max_workers}),\n            )\n\n    def _store_copy_possible',
+    "                max_workers=max_workers,\n            )\n\n    def _store_copy_possible",
+    "tests/test_az_fake.py::test_the_generic_calls_get_max_workers_only_when_it_is_given",
+    "copy() hands pathapi a max_workers it was not given, which a release without the keyword refuses",
+)
+
+mutant(
+    "objpath-uri-copy-always-passes-max-workers",
+    "_uri_store.py",
+    '                # Only when given: pathapi 0.1.1 has no such keyword.\n                **({} if max_workers is None else {"max_workers": max_workers}),\n',
+    "                max_workers=max_workers,\n",
+    "tests/test_az_fake.py::test_the_generic_calls_get_max_workers_only_when_it_is_given",
+    "the URI copy() hands pathapi a max_workers it was not given",
+)

{objpath-0.1.0 → objpath-0.1.1}/tests/test_az_fake.py

@@ -1422,3 +1422,70 @@ def test_r_plus_reads_its_initial_content_as_one_version(az, monkeypatch):
         az("az://account/container/big.bin", backend).open("r+b")
     assert info.value.errno == _stale_errno()
     assert container.objects["big.bin"] == NEW and container.uploads == []
+
+
+# --- max_workers ---------------------------------------------------------------------
+
+
+def _generic_owner(path, name):
+    """The class whose `name` the override of `path`'s class reaches with `super()`."""
+    # A URI path hands `rm()` to its core path, whose `super()` is the generic one.
+    if name == "rm":
+        path = getattr(path, "_core_path", path)
+    owners = [base for base in type(path).__mro__ if name in vars(base)]
+    return owners[1]
+
+
+@pytest.mark.parametrize("name", ["rm", "copy"])
+def test_rm_and_copy_have_the_parameters_of_the_path_ones_and_max_workers(az, name):
+    import inspect
+
+    from pathapi import Path
+
+    expected = inspect.signature(getattr(Path, name)).parameters
+    actual = inspect.signature(getattr(type(az("az://account/c/k")), name)).parameters
+    assert [n for n in actual if n != "max_workers"] == [
+        n for n in expected if n != "max_workers"
+    ]
+    assert actual["max_workers"].kind is inspect.Parameter.KEYWORD_ONLY
+    assert actual["max_workers"].default is None
+    for pname, parameter in expected.items():
+        assert actual[pname].kind == parameter.kind, pname
+        assert actual[pname].default == parameter.default, pname
+
+
+def test_the_batch_delete_and_the_service_copy_ignore_max_workers(az):
+    backend, container = _container_with(**{"dir/a.txt": b"a", "dir/b.txt": b"b"})
+
+    az("az://account/container/dir/a.txt", backend).copy(
+        az("az://account/container/c.txt", backend), max_workers=4
+    )
+    az("az://account/container/dir", backend).rm(recursive=True, max_workers=4)
+
+    assert container.copies == [("dir/a.txt", "c.txt")]
+    assert sorted(container.objects) == ["c.txt"]
+
+
+@pytest.mark.parametrize("name", ["rm", "copy"])
+@pytest.mark.parametrize("workers", [None, 4])
+def test_the_generic_calls_get_max_workers_only_when_it_is_given(
+    az, monkeypatch, name, workers
+):
+    seen = []
+    source = az("az://account/container/a.txt")
+    monkeypatch.setattr(
+        _generic_owner(source, name),
+        name,
+        lambda self, *args, **kw: seen.append(kw),
+    )
+    extra = {} if workers is None else {"max_workers": workers}
+
+    if name == "rm":
+        source.rm(**extra)
+    else:
+        # Another backend: the streamed copy, which is the generic one.
+        source.copy(az("az://account/container/b.txt"), **extra)
+
+    assert [kw.get("max_workers", "absent") for kw in seen] == [
+        "absent" if workers is None else workers
+    ]