lsst-resources 29.2025.1700__py3-none-any.whl → 29.2025.4600__py3-none-any.whl

lsst/resources/s3.py

@@ -13,6 +13,7 @@ from __future__ import annotations
 
 __all__ = ("S3ResourcePath",)
 
+import concurrent.futures
 import contextlib
 import io
 import logging
@@ -20,17 +21,19 @@ import os
 import re
 import sys
 import threading
+from collections import defaultdict
 from collections.abc import Iterable, Iterator
 from functools import cache, cached_property
 from typing import IO, TYPE_CHECKING, cast
 
 from botocore.exceptions import ClientError
 
+from lsst.utils.iteration import chunk_iterable
 from lsst.utils.timer import time_this
 
 from ._resourceHandles._baseResourceHandle import ResourceHandleProtocol
 from ._resourceHandles._s3ResourceHandle import S3ResourceHandle
-from ._resourcePath import ResourcePath
+from ._resourcePath import _EXECUTOR_TYPE, MBulkResult, ResourcePath, _get_executor_class, _patch_environ
 from .s3utils import (
     _get_s3_connection_parameters,
     _s3_disable_bucket_validation,
@@ -44,6 +47,7 @@ from .s3utils import (
     s3CheckFileExists,
     translate_client_error,
 )
+from .utils import _get_num_workers
 
 try:
     from boto3.s3.transfer import TransferConfig  # type: ignore
@@ -220,7 +224,9 @@ class S3ResourcePath(ResourcePath):
         return bucket
 
     @classmethod
-    def _mexists(cls, uris: Iterable[ResourcePath]) -> dict[ResourcePath, bool]:
+    def _mexists(
+        cls, uris: Iterable[ResourcePath], *, num_workers: int | None = None
+    ) -> dict[ResourcePath, bool]:
         # Force client to be created for each profile before creating threads.
         profiles = set[str | None]()
         for path in uris:
@@ -230,7 +236,125 @@ class S3ResourcePath(ResourcePath):
         for profile in profiles:
             getS3Client(profile)
 
-        return super()._mexists(uris)
+        return super()._mexists(uris, num_workers=num_workers)
+
+    @classmethod
+    def _mremove(cls, uris: Iterable[ResourcePath]) -> dict[ResourcePath, MBulkResult]:
+        # Delete multiple objects in one API call.
+        # Must group by profile and bucket.
+        grouped_uris: dict[tuple[str | None, str], list[S3ResourcePath]] = defaultdict(list)
+        for uri in uris:
+            uri = cast(S3ResourcePath, uri)
+            grouped_uris[uri._profile, uri._bucket].append(uri)
+
+        results: dict[ResourcePath, MBulkResult] = {}
+        for related_uris in grouped_uris.values():
+            # API requires no more than 1000 per call.
+            chunk_num = 0
+            chunks: list[tuple[ResourcePath, ...]] = []
+            key_to_uri: dict[str, ResourcePath] = {}
+            for chunk in chunk_iterable(related_uris, chunk_size=1_000):
+                for uri in chunk:
+                    key = uri.relativeToPathRoot
+                    key_to_uri[key] = uri
+                    # Default to assuming everything worked.
+                    results[uri] = MBulkResult(True, None)
+                chunk_num += 1
+                chunks.append(chunk)
+
+            # Bulk remove.
+            with time_this(
+                log,
+                msg="Bulk delete; %d chunk%s; totalling %d dataset%s",
+                args=(
+                    len(chunks),
+                    "s" if len(chunks) != 1 else "",
+                    len(related_uris),
+                    "s" if len(related_uris) != 1 else "",
+                ),
+            ):
+                errored = cls._mremove_select(chunks)
+
+            # Update with error information.
+            results.update(errored)
+
+        return results
+
+    @classmethod
+    def _mremove_select(cls, chunks: list[tuple[ResourcePath, ...]]) -> dict[ResourcePath, MBulkResult]:
+        if len(chunks) == 1:
+            # Do the removal directly without futures.
+            return cls._delete_objects_wrapper(chunks[0])
+        pool_executor_class = _get_executor_class()
+        if issubclass(pool_executor_class, concurrent.futures.ProcessPoolExecutor):
+            # Patch the environment to make it think there is only one worker
+            # for each subprocess.
+            with _patch_environ({"LSST_RESOURCES_NUM_WORKERS": "1"}):
+                return cls._mremove_with_pool(pool_executor_class, chunks)
+        else:
+            return cls._mremove_with_pool(pool_executor_class, chunks)
+
+    @classmethod
+    def _mremove_with_pool(
+        cls,
+        pool_executor_class: _EXECUTOR_TYPE,
+        chunks: list[tuple[ResourcePath, ...]],
+        *,
+        num_workers: int | None = None,
+    ) -> dict[ResourcePath, MBulkResult]:
+        # Different name because different API to base class.
+        # No need to make more workers than we have chunks.
+        max_workers = num_workers if num_workers is not None else min(len(chunks), _get_num_workers())
+        results: dict[ResourcePath, MBulkResult] = {}
+        with pool_executor_class(max_workers=max_workers) as remove_executor:
+            future_remove = {
+                remove_executor.submit(cls._delete_objects_wrapper, chunk): i
+                for i, chunk in enumerate(chunks)
+            }
+            for future in concurrent.futures.as_completed(future_remove):
+                try:
+                    results.update(future.result())
+                except Exception as e:
+                    # The chunk utterly failed.
+                    chunk = chunks[future_remove[future]]
+                    for uri in chunk:
+                        results[uri] = MBulkResult(False, e)
+        return results
+
+    @classmethod
+    def _delete_objects_wrapper(cls, uris: tuple[ResourcePath, ...]) -> dict[ResourcePath, MBulkResult]:
+        """Convert URIs to keys and call low-level API."""
+        if not uris:
+            return {}
+        keys: list[dict[str, str]] = []
+        key_to_uri: dict[str, ResourcePath] = {}
+        for uri in uris:
+            key = uri.relativeToPathRoot
+            key_to_uri[key] = uri
+            keys.append({"Key": key})
+
+        first_uri = cast(S3ResourcePath, uris[0])
+        results = cls._delete_related_objects(first_uri.client, first_uri._bucket, keys)
+
+        # Remap error object keys to uris.
+        return {key_to_uri[key]: result for key, result in results.items()}
+
+    @classmethod
+    @backoff.on_exception(backoff.expo, retryable_io_errors, max_time=max_retry_time)
+    def _delete_related_objects(
+        cls, client: boto3.client, bucket: str, keys: list[dict[str, str]]
+    ) -> dict[str, MBulkResult]:
+        # Delete multiple objects from the same bucket, allowing for backoff
+        # retry.
+        response = client.delete_objects(Bucket=bucket, Delete={"Objects": keys, "Quiet": True})
+        # Use Quiet mode so we assume everything worked unless told otherwise.
+        # Only returning errors -- indexed by Key name.
+        errors: dict[str, MBulkResult] = {}
+        for errored_key in response.get("Errors", []):
+            errors[errored_key["Key"]] = MBulkResult(
+                False, ClientError({"Error": errored_key}, f"delete_objects: {errored_key['Key']}")
+            )
+        return errors
 
     @backoff.on_exception(backoff.expo, retryable_io_errors, max_time=max_retry_time)
     def exists(self) -> bool:
@@ -353,7 +477,10 @@ class S3ResourcePath(ResourcePath):
 
         return s3, f"{self._bucket}/{self.relativeToPathRoot}"
 
-    def _as_local(self, multithreaded: bool = True, tmpdir: ResourcePath | None = None) -> tuple[str, bool]:
+    @contextlib.contextmanager
+    def _as_local(
+        self, multithreaded: bool = True, tmpdir: ResourcePath | None = None
+    ) -> Iterator[ResourcePath]:
         """Download object from S3 and place in temporary directory.
 
         Parameters
@@ -370,13 +497,12 @@ class S3ResourcePath(ResourcePath):
 
         Returns
         -------
-        path : `str`
-            Path to local temporary file.
-        temporary : `bool`
-            Always returns `True`. This is always a temporary file.
+        local_uri : `ResourcePath`
+            A URI to a local POSIX file corresponding to a local temporary
+            downloaded copy of the resource.
         """
         with (
-            ResourcePath.temporary_uri(prefix=tmpdir, suffix=self.getExtension(), delete=False) as tmp_uri,
+            ResourcePath.temporary_uri(prefix=tmpdir, suffix=self.getExtension(), delete=True) as tmp_uri,
             self._use_threads_temp_override(multithreaded),
             time_this(log, msg="Downloading %s to local file", args=(self,)),
         ):
@@ -387,7 +513,7 @@ class S3ResourcePath(ResourcePath):
             )
             with tmp_uri.open("wb") as tmpFile:
                 self._download_file(tmpFile, progress)
-        return tmp_uri.ospath, True
+            yield tmp_uri
 
     @backoff.on_exception(backoff.expo, all_retryable_errors, max_time=max_retry_time)
     def _upload_file(self, local_file: ResourcePath, progress: ProgressPercentage | None) -> None:
@@ -418,7 +544,7 @@ class S3ResourcePath(ResourcePath):
         try:
             self.client.copy_object(CopySource=copy_source, Bucket=self._bucket, Key=self.relativeToPathRoot)
         except (self.client.exceptions.NoSuchKey, self.client.exceptions.NoSuchBucket) as err:
-            raise FileNotFoundError("No such resource to transfer: {self}") from err
+            raise FileNotFoundError(f"No such resource to transfer: {src} -> {self}") from err
         except ClientError as err:
             translate_client_error(err, self)
             raise
@@ -485,10 +611,10 @@ class S3ResourcePath(ResourcePath):
         timer_msg = "Transfer from %s to %s"
         timer_args = (src, self)
 
-        if isinstance(src, type(self)):
-            # Looks like an S3 remote uri so we can use direct copy
-            # note that boto3.resource.meta.copy is cleverer than the low
-            # level copy_object
+        if isinstance(src, type(self)) and self.client == src.client:
+            # Looks like an S3 remote uri so we can use direct copy.
+            # This only works if the source and destination are using the same
+            # S3 endpoint and profile.
             with time_this(log, msg=timer_msg, args=timer_args):
                 self._copy_from(src)
 

lsst/resources/s3utils.py

@@ -53,6 +53,7 @@ except ImportError:
 
 from ._resourcePath import ResourcePath
 from .location import Location
+from .utils import _get_num_workers
 
 # https://pypi.org/project/backoff/
 try:
@@ -246,7 +247,13 @@ def _s3_disable_bucket_validation(client: boto3.client) -> None:
 @functools.lru_cache
 def _get_s3_client(endpoint_config: _EndpointConfig, skip_validation: bool) -> boto3.client:
     # Helper function to cache the client for this endpoint
-    config = botocore.config.Config(read_timeout=180, retries={"mode": "adaptive", "max_attempts": 10})
+    # boto seems to assume it will always have at least 10 available.
+    max_pool_size = max(_get_num_workers(), 10)
+    config = botocore.config.Config(
+        read_timeout=180,
+        max_pool_connections=max_pool_size,
+        retries={"mode": "adaptive", "max_attempts": 10},
+    )
 
     session = boto3.Session(profile_name=endpoint_config.profile)
 

lsst/resources/schemeless.py

@@ -105,13 +105,16 @@ class SchemelessResourcePath(FileResourcePath):
             return stat.S_ISDIR(status.st_mode)
         return self.dirLike
 
-    def relative_to(self, other: ResourcePath) -> str | None:
+    def relative_to(self, other: ResourcePath, walk_up: bool = False) -> str | None:
         """Return the relative path from this URI to the other URI.
 
         Parameters
         ----------
         other : `ResourcePath`
             URI to use to calculate the relative path.
+        walk_up : `bool`, optional
+            Control whether "``..``" can be used to resolve a relative path.
+            Default is `False`. Can not be `True` on Python version 3.11.
 
         Returns
         -------
@@ -146,8 +149,8 @@ class SchemelessResourcePath(FileResourcePath):
             raise RuntimeError(f"Unexpected combination of {child}.relative_to({other}).")
 
         if child is None:
-            return super().relative_to(other)
-        return child.relative_to(other)
+            return super().relative_to(other, walk_up=walk_up)
+        return child.relative_to(other, walk_up=walk_up)
 
     @classmethod
     def _fixupPathUri(

lsst/resources/tests.py

@@ -17,6 +17,7 @@ import os
 import pathlib
 import random
 import string
+import sys
 import tempfile
 import unittest
 import urllib.parse
@@ -61,18 +62,18 @@ def _check_open(
     """
     text_content = "abcdefghijklmnopqrstuvwxyz🙂"
     bytes_content = uuid.uuid4().bytes
-    content_by_mode_suffix = {
+    content_by_mode_suffix: dict[str, str | bytes] = {
         "": text_content,
         "t": text_content,
         "b": bytes_content,
     }
-    empty_content_by_mode_suffix = {
+    empty_content_by_mode_suffix: dict[str, str | bytes] = {
         "": "",
         "t": "",
         "b": b"",
     }
     # To appease mypy
-    double_content_by_mode_suffix = {
+    double_content_by_mode_suffix: dict[str, str | bytes] = {
         "": text_content + text_content,
         "t": text_content + text_content,
         "b": bytes_content + bytes_content,
@@ -143,6 +144,16 @@ def _check_open(
             content_read = read_buffer.read()
             test_case.assertEqual(len(content_read), 0, f"Read: {content_read!r}, expected empty.")
 
+        # Write multiple chunks with flushing to ensure that any handles that
+        # cache without flushing work properly.
+        n = 3
+        with uri.open("w" + mode_suffix, **kwargs) as write_buffer:
+            for _ in range(n):
+                write_buffer.write(content)
+                write_buffer.flush()
+        with uri.open("r" + mode_suffix, **kwargs) as read_buffer:
+            test_case.assertEqual(read_buffer.read(), content * n)
+
         # Write two copies of the content, overwriting the single copy there.
         with uri.open("w" + mode_suffix, **kwargs) as write_buffer:
             write_buffer.write(double_content)
@@ -365,6 +376,19 @@ class GenericTestCase(_GenericTestCase):
         parent = ResourcePath("d/e.txt", forceAbsolute=False)
         self.assertIsNone(child.relative_to(parent), f"{child}.relative_to({parent})")
 
+        # Allow .. in response.
+        child = ResourcePath(self._make_uri("a/b/c/d.txt"), forceAbsolute=False)
+        parent = ResourcePath(self._make_uri("a/b/d/e/"), forceAbsolute=False)
+        self.assertIsNone(child.relative_to(parent), f"{child}.relative_to({parent})")
+
+        if sys.version_info >= (3, 12, 0):
+            # Fails on python 3.11.
+            self.assertEqual(
+                child.relative_to(parent, walk_up=True),
+                "../../c/d.txt",
+                f"{child}.relative_to({parent}, walk_up=True)",
+            )
+
     def test_parents(self) -> None:
         """Test of splitting and parent walking."""
         parent = ResourcePath(self._make_uri("somedir"), forceDirectory=True)
@@ -382,6 +406,14 @@ class GenericTestCase(_GenericTestCase):
         self.assertEqual(child_file.parent().parent(), parent)
         self.assertEqual(child_subdir.dirname(), child_subdir)
 
+        # Make sure that the parent doesn't retain any fragment from the
+        # child.
+        child_fragment = child_subdir.join("a.txt#fragment")
+        self.assertEqual(child_fragment.fragment, "fragment")
+        fragment_parent = child_fragment.parent()
+        self.assertEqual(fragment_parent.fragment, "")
+        self.assertTrue(str(fragment_parent).endswith("/"))
+
     def test_escapes(self) -> None:
         """Special characters in file paths."""
         src = self.root_uri.join("bbb/???/test.txt")
@@ -486,6 +518,13 @@ class GenericTestCase(_GenericTestCase):
         self.assertEqual(fnew3.fragment, "fragment")
         self.assertEqual(fnew3.basename(), "b.txt", msg=f"Got: {fnew3._uri}")
 
+        # Check that fragment on the directory is dropped on join.
+        frag_dir = add_dir.join("subdir/#dir_fragment")
+        self.assertEqual(frag_dir.fragment, "dir_fragment")
+        fnew4 = frag_dir.join("a.txt")
+        self.assertEqual(fnew4.fragment, "")
+        self.assertTrue(str(fnew4).endswith("/a.txt"))
+
         # Join a resource path.
         subpath = ResourcePath("a/b.txt#fragment2", forceAbsolute=False, forceDirectory=False)
         fnew3 = root.join(subpath)
@@ -557,6 +596,10 @@ class GenericReadWriteTestCase(_GenericTestCase):
 
     transfer_modes: tuple[str, ...] = ("copy", "move")
     testdir: str | None = None
+    # Number of files to use for mremove() testing to ensure difference code
+    # paths are hit. Do not want to generically use many files for schemes
+    # where it makes no difference.
+    n_mremove_files: int = 15
 
     def setUp(self) -> None:
         if self.scheme is None:
@@ -1023,22 +1066,33 @@ class GenericReadWriteTestCase(_GenericTestCase):
         # A file that is not there.
         file = root.join("config/basic/butler.yaml")
 
-        # Create some files.
-        expected_files = {
-            "dir1/a.yaml",
-            "dir1/b.yaml",
-            "dir2/e.yaml",
-        }
-        expected_uris = {root.join(f) for f in expected_files}
+        # Create some files. Most schemes the code paths do not change for 10
+        # vs 1000 files but in some schemes it does.
+        expected_files = [f"dir1/f{n}.yaml" for n in range(self.n_mremove_files)]
+        expected_uris = [root.join(f) for f in expected_files]
         for uri in expected_uris:
             uri.write(b"")
             self.assertTrue(uri.exists())
-        expected_uris.add(file)
+        expected_uris.append(file)
 
-        multi = ResourcePath.mexists(expected_uris)
+        # Force to run with fewer workers than there are files.
+        multi = ResourcePath.mexists(expected_uris, num_workers=3)
 
         for uri, is_there in multi.items():
             if uri == file:
                 self.assertFalse(is_there)
             else:
                 self.assertTrue(is_there)
+
+        # Clean up. Unfortunately POSIX raises a FileNotFoundError but
+        # S3 boto does not complain if there is no key.
+        ResourcePath.mremove(expected_uris, do_raise=False)
+
+        # Check they were really removed.
+        multi = ResourcePath.mexists(expected_uris, num_workers=3)
+        for uri, is_there in multi.items():
+            self.assertFalse(is_there)
+
+        # Clean up a subset of files that are already gone, but this can
+        # trigger a different code path.
+        ResourcePath.mremove(expected_uris[:5], do_raise=False)

lsst/resources/utils.py

@@ -15,6 +15,7 @@ __all__ = ("NoTransaction", "TransactionProtocol", "get_tempdir", "os2posix", "p
 
 import contextlib
 import logging
+import multiprocessing
 import os
 import posixpath
 import shutil
@@ -33,6 +34,11 @@ IS_POSIX = os.sep == posixpath.sep
 # posix means posix and only determine explicitly in the non-posix case.
 OS_ROOT_PATH = posixpath.sep if IS_POSIX else Path().resolve().root
 
+# Maximum number of worker threads for parallelized operations.
+# If greater than 10, be aware that this number has to be consistent
+# with connection pool sizing (for example in urllib3).
+MAX_WORKERS = 10
+
 log = logging.getLogger(__name__)
 
 
@@ -226,3 +232,40 @@ def ensure_directory_is_writeable(directory_path: str | bytes) -> None:
     desired_mode = current_mode | stat.S_IWUSR | stat.S_IXUSR
     if current_mode != desired_mode:
         os.chmod(directory_path, desired_mode)
+
+
+def _get_int_env_var(env_var: str) -> int | None:
+    int_value = None
+    env_value = os.getenv(env_var)
+    if env_value is not None:
+        with contextlib.suppress(TypeError):
+            int_value = int(env_value)
+    return int_value
+
+
+@cache
+def _get_num_workers() -> int:
+    f"""Calculate the number of workers to use.
+
+    Returns
+    -------
+    num : `int`
+        The number of workers to use. Will use the value of the
+        ``LSST_RESOURCES_NUM_WORKERS`` environment variable if set. Will fall
+        back to using the CPU count (plus 2) but capped at {MAX_WORKERS}.
+    """
+    num_workers: int | None = None
+    num_workers = _get_int_env_var("LSST_RESOURCES_NUM_WORKERS")
+
+    # If someone is explicitly specifying a number, let them use that number.
+    if num_workers is not None:
+        return num_workers
+
+    if num_workers is None:
+        # CPU_LIMIT is used on nublado.
+        cpu_limit = _get_int_env_var("CPU_LIMIT") or multiprocessing.cpu_count()
+        if cpu_limit is not None:
+            num_workers = cpu_limit + 2
+
+    # But don't ever return more than the maximum allowed.
+    return min([num_workers, MAX_WORKERS])

lsst/resources/version.py

@@ -1,2 +1,2 @@
 __all__ = ["__version__"]
-__version__ = "29.2025.1700"
+__version__ = "29.2025.4600"

{lsst_resources-29.2025.1700.dist-info → lsst_resources-29.2025.4600.dist-info}/METADATA

@@ -1,17 +1,17 @@
 Metadata-Version: 2.4
 Name: lsst-resources
-Version: 29.2025.1700
+Version: 29.2025.4600
 Summary: An abstraction layer for reading and writing from URI file resources.
 Author-email: Rubin Observatory Data Management <dm-admin@lists.lsst.org>
-License: BSD 3-Clause License
+License-Expression: BSD-3-Clause
 Project-URL: Homepage, https://github.com/lsst/resources
 Keywords: lsst
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.11.0
 Description-Content-Type: text/markdown
 License-File: COPYRIGHT

lsst_resources-29.2025.4600.dist-info/RECORD

@@ -0,0 +1,31 @@
+lsst/__init__.py,sha256=9I6UQ9gj-ZcPlvsa0OPBo76UujxXVehVzw9yMAOQvyM,466
+lsst/resources/__init__.py,sha256=BDj6uokvd0ZQNGl-Xgz5gZd83Z0L2gFqGSk0KJpylP8,778
+lsst/resources/_resourcePath.py,sha256=fnB8XNUfk25lV378U0kg1O6c1QnSJL7F9iqaEt08IOA,74508
+lsst/resources/dav.py,sha256=ZYP7PnQzS7epm5woxnn1_t1XhsPQZm6_q1kv8baUfn4,32100
+lsst/resources/davutils.py,sha256=5geEl_44lrWX-Si1VDfYJ6WP1rg22PBqlyD_v1HE4yI,100300
+lsst/resources/file.py,sha256=v2XLOzflfhI6kjUGB1mE8p-1e1B2eE58PW-qsQSCqdA,24360
+lsst/resources/gs.py,sha256=3qMEqO1wIK05BJmuUHtsEunuYWgR4-eB5Z3ffxEtb0o,12827
+lsst/resources/http.py,sha256=WSx2VXKFd6486TytV2NMfdgLntioL6FvliZWpn9LtDE,92426
+lsst/resources/location.py,sha256=x3Tq0x5o1OXYmZDxYBenUG1N71wtDhnjVAr3s2ZEiu8,7937
+lsst/resources/mem.py,sha256=xCpGgvxF2gmO5gLkOikKvIet2RPvaPCiARenR9pUWCk,1115
+lsst/resources/packageresource.py,sha256=vnfeRlpVwpC5cDQZE6Lnh8EH6oZy1sH2vLz9ONYjJ4k,6817
+lsst/resources/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lsst/resources/s3.py,sha256=NGJPM4BjtqFIPvg9vbp_blrIRt009NbOm06cr65Wqmw,29662
+lsst/resources/s3utils.py,sha256=ojWf9BPrK9mhGQ8jvs4_8Nsqf9360e79U5FnPTxe24A,14576
+lsst/resources/schemeless.py,sha256=9tgqf0eQI3ErGpGSscTRFk_8amF6GwpykPBaTa-KqLI,10909
+lsst/resources/tests.py,sha256=UD2Pql8olpW9oCDlsA_jtl23SZtknp7ReuJHLcMPSa0,46237
+lsst/resources/utils.py,sha256=6O3Mq7JbPEtqyD2lM77pRpwcPMfV5SxiNMknw-F2vNs,8097
+lsst/resources/version.py,sha256=vB8XwkFrtPN40DIouI1mFlxm5jpAZvcGwleFGT1yZhI,55
+lsst/resources/_resourceHandles/__init__.py,sha256=zOcZ8gVEBdAWcHJaZabA8Vdq-wAVcxjbmA_1b1IWM6M,76
+lsst/resources/_resourceHandles/_baseResourceHandle.py,sha256=lQwxDOmFUNJndTxsjpz-HxrQBL0L-z4aXQocHdOEI7c,4676
+lsst/resources/_resourceHandles/_davResourceHandle.py,sha256=xcJNFUj8VzlPOKlHdXXoFFyiLNiSFiT-RFNqJRzKniQ,6799
+lsst/resources/_resourceHandles/_fileResourceHandle.py,sha256=2nC8tfP_ynAfjpzrtkw_1ahx1CuMEFpZ5mLmofSShUk,3676
+lsst/resources/_resourceHandles/_httpResourceHandle.py,sha256=Yami8IVGeru4bLQCag-OvGG0ltz1qyEg57FY4IEB87Y,10995
+lsst/resources/_resourceHandles/_s3ResourceHandle.py,sha256=Cp-eBtptskbmthy3DwLKPpYPLvU_lrqtK10X37inHt0,12406
+lsst_resources-29.2025.4600.dist-info/licenses/COPYRIGHT,sha256=yazVsoMmFwhiw5itGrdT4YPmXbpsQyUFjlpOyZIa77M,148
+lsst_resources-29.2025.4600.dist-info/licenses/LICENSE,sha256=7wrtgl8meQ0_RIuv2TjIKpAnNrl-ODH-QLwyHe9citI,1516
+lsst_resources-29.2025.4600.dist-info/METADATA,sha256=AHUIXOjx8MQBorWKENL6Q360iyEcLVrF7IOzOEDMGIM,2240
+lsst_resources-29.2025.4600.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lsst_resources-29.2025.4600.dist-info/top_level.txt,sha256=eUWiOuVVm9wwTrnAgiJT6tp6HQHXxIhj2QSZ7NYZH80,5
+lsst_resources-29.2025.4600.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+lsst_resources-29.2025.4600.dist-info/RECORD,,

{lsst_resources-29.2025.1700.dist-info → lsst_resources-29.2025.4600.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

lsst_resources-29.2025.1700.dist-info/RECORD

@@ -1,28 +0,0 @@
-lsst/__init__.py,sha256=9I6UQ9gj-ZcPlvsa0OPBo76UujxXVehVzw9yMAOQvyM,466
-lsst/resources/__init__.py,sha256=BDj6uokvd0ZQNGl-Xgz5gZd83Z0L2gFqGSk0KJpylP8,778
-lsst/resources/_resourcePath.py,sha256=xTVyDHD-UHlF5FeDvSXXnsmOuoSFnORZD_wMksxiFfA,64926
-lsst/resources/file.py,sha256=-jPuoHvTEtx5tnDyNkfwhWAyX0cTwkuMd-JvJn9EGdE,23226
-lsst/resources/gs.py,sha256=Lpo5GAzH7R7HG8E5RMGOdP4j4hjWJn-k6M3OXj0nHQM,12783
-lsst/resources/http.py,sha256=JW3cBe4MERyjopFKkELui1BRr4b4Mkgp0Iqt9YFIxuc,88227
-lsst/resources/location.py,sha256=x3Tq0x5o1OXYmZDxYBenUG1N71wtDhnjVAr3s2ZEiu8,7937
-lsst/resources/mem.py,sha256=VOWh7XxJPfqKcFdLZSjKEAfORQ2AHZHpxmjT8LniV60,1008
-lsst/resources/packageresource.py,sha256=vnfeRlpVwpC5cDQZE6Lnh8EH6oZy1sH2vLz9ONYjJ4k,6817
-lsst/resources/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lsst/resources/s3.py,sha256=wrOMdFWltxpGEWeL--kPCbk5Le_viCIsEn4lOPZbXhM,24124
-lsst/resources/s3utils.py,sha256=cKJ9GWHETHhn1djezyikWwAaw4k1B3hFvfif96THHDQ,14355
-lsst/resources/schemeless.py,sha256=GfJcKzZ0XIeepfQdW4HPZWiZlSp_ej0SEtSiJTrDUQs,10666
-lsst/resources/tests.py,sha256=MLB8hERKuNredzzg3Qq9M_U7IesV3xrbcjFwKuMp3Ok,43513
-lsst/resources/utils.py,sha256=IHVrOdj0szNWxiXk-jbZu1RhTR8WXks1vI9JCpBxeBA,6706
-lsst/resources/version.py,sha256=k6PcnewHb2vETZCsCS6q8mJ_uyMg-otfwuQ8B0oDDwQ,55
-lsst/resources/_resourceHandles/__init__.py,sha256=zOcZ8gVEBdAWcHJaZabA8Vdq-wAVcxjbmA_1b1IWM6M,76
-lsst/resources/_resourceHandles/_baseResourceHandle.py,sha256=lQwxDOmFUNJndTxsjpz-HxrQBL0L-z4aXQocHdOEI7c,4676
-lsst/resources/_resourceHandles/_fileResourceHandle.py,sha256=A7_WQPzD0ZlOzNmaI_TPdZybrNxrXPkNHWVla3UFxfs,3676
-lsst/resources/_resourceHandles/_httpResourceHandle.py,sha256=JRjpE-ZQfgKX5OyVLulIbzW38FdhovcoOd1D4rhb5vk,10900
-lsst/resources/_resourceHandles/_s3ResourceHandle.py,sha256=NkDmPb9bm_zMvr6mMnb-tBmqJDt0yUJrt2gZXR8l7ok,12923
-lsst_resources-29.2025.1700.dist-info/licenses/COPYRIGHT,sha256=yazVsoMmFwhiw5itGrdT4YPmXbpsQyUFjlpOyZIa77M,148
-lsst_resources-29.2025.1700.dist-info/licenses/LICENSE,sha256=7wrtgl8meQ0_RIuv2TjIKpAnNrl-ODH-QLwyHe9citI,1516
-lsst_resources-29.2025.1700.dist-info/METADATA,sha256=gybCKJmJyKdf0oqRgCbF6IKA0SzNalaw1nhptr1Y51I,2237
-lsst_resources-29.2025.1700.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-lsst_resources-29.2025.1700.dist-info/top_level.txt,sha256=eUWiOuVVm9wwTrnAgiJT6tp6HQHXxIhj2QSZ7NYZH80,5
-lsst_resources-29.2025.1700.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-lsst_resources-29.2025.1700.dist-info/RECORD,,