lsst-resources 29.2025.1600__py3-none-any.whl → 29.2025.1800__py3-none-any.whl

lsst/resources/_resourceHandles/_httpResourceHandle.py

@@ -168,7 +168,9 @@ class HttpReadResourceHandle(BaseResourceHandle[bytes]):
             # return the result
             self._completeBuffer = io.BytesIO()
             with time_this(self._log, msg="Read from remote resource %s", args=(self._url,)):
-                resp = self._session.get(_dav_to_http(self._url), stream=False, timeout=self._timeout)
+                with self._session as session:
+                    resp = session.get(_dav_to_http(self._url), stream=False, timeout=self._timeout)
+
             if (code := resp.status_code) not in (requests.codes.ok, requests.codes.partial):
                 raise FileNotFoundError(f"Unable to read resource {self._url}; status code: {code}")
             self._completeBuffer.write(resp.content)
@@ -190,9 +192,10 @@ class HttpReadResourceHandle(BaseResourceHandle[bytes]):
         with time_this(
             self._log, msg="Read from remote resource %s using headers %s", args=(self._url, headers)
         ):
-            resp = self._session.get(
-                _dav_to_http(self._url), stream=False, timeout=self._timeout, headers=headers
-            )
+            with self._session as session:
+                resp = session.get(
+                    _dav_to_http(self._url), stream=False, timeout=self._timeout, headers=headers
+                )
 
         if resp.status_code == requests.codes.range_not_satisfiable:
             # Must have run off the end of the file. A standard file handle

lsst/resources/_resourcePath.py

@@ -19,14 +19,13 @@ import copy
 import io
 import locale
 import logging
-import multiprocessing
 import os
 import posixpath
 import re
 import urllib.parse
-from functools import cache
 from pathlib import Path, PurePath, PurePosixPath
 from random import Random
+from typing import TypeAlias
 
 try:
     import fsspec
@@ -39,7 +38,7 @@ from collections.abc import Iterable, Iterator
 from typing import TYPE_CHECKING, Any, Literal, NamedTuple, overload
 
 from ._resourceHandles._baseResourceHandle import ResourceHandleProtocol
-from .utils import get_tempdir
+from .utils import _get_num_workers, get_tempdir
 
 if TYPE_CHECKING:
     from .utils import TransactionProtocol
@@ -53,11 +52,6 @@ ESCAPES_RE = re.compile(r"%[A-F0-9]{2}")
 # Precomputed escaped hash
 ESCAPED_HASH = urllib.parse.quote("#")
 
-# 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
-
 
 class MTransferResult(NamedTuple):
     """Report on a bulk transfer."""
@@ -66,36 +60,73 @@ class MTransferResult(NamedTuple):
     exception: Exception | None
 
 
-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
+_EXECUTOR_TYPE: TypeAlias = type[
+    concurrent.futures.ThreadPoolExecutor | concurrent.futures.ProcessPoolExecutor
+]
+
+# Cache value for executor class so as not to issue warning multiple
+# times but still allow tests to override the value.
+_POOL_EXECUTOR_CLASS: _EXECUTOR_TYPE | None = None
 
 
-@cache
-def _get_num_workers() -> int:
-    f"""Calculate the number of workers to use.
+def _get_executor_class() -> _EXECUTOR_TYPE:
+    """Return the executor class used for parallelized execution.
 
     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}.
+    cls : `concurrent.futures.Executor`
+        The ``Executor`` class. Default is
+        `concurrent.futures.ThreadPoolExecutor`. Can be set explicitly by
+        setting the ``$LSST_RESOURCES_EXECUTOR`` environment variable to
+        "thread" or "process". Returns "thread" pool if the value of the
+        variable is not recognized.
+    """
+    global _POOL_EXECUTOR_CLASS
+
+    if _POOL_EXECUTOR_CLASS is not None:
+        return _POOL_EXECUTOR_CLASS
+
+    pool_executor_classes = {
+        "threads": concurrent.futures.ThreadPoolExecutor,
+        "process": concurrent.futures.ProcessPoolExecutor,
+    }
+    default_executor = "threads"
+    external = os.getenv("LSST_RESOURCES_EXECUTOR", default_executor)
+    if not external:
+        external = default_executor
+    if external not in pool_executor_classes:
+        log.warning(
+            "Unrecognized value of '%s' for LSST_RESOURCES_EXECUTOR env var. Using '%s'",
+            external,
+            default_executor,
+        )
+        external = default_executor
+    _POOL_EXECUTOR_CLASS = pool_executor_classes[external]
+    return _POOL_EXECUTOR_CLASS
+
+
+@contextlib.contextmanager
+def _patch_environ(new_values: dict[str, str]) -> Iterator[None]:
+    """Patch os.environ temporarily using the supplied values.
+
+    Parameters
+    ----------
+    new_values : `dict` [ `str`, `str` ]
+        New values to be stored in the environment.
     """
-    num_workers: int | None = None
-    num_workers = _get_int_env_var("LSST_RESOURCES_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
+    old_values: dict[str, str] = {}
+    for k, v in new_values.items():
+        if k in os.environ:
+            old_values[k] = os.environ[k]
+        os.environ[k] = v
 
-    # But don't ever return more than the maximum allowed.
-    return min([num_workers, MAX_WORKERS])
+    try:
+        yield
+    finally:
+        for k in new_values:
+            del os.environ[k]
+            if k in old_values:
+                os.environ[k] = old_values[k]
 
 
 class ResourcePath:  # numpydoc ignore=PR02
@@ -882,13 +913,20 @@ class ResourcePath:  # numpydoc ignore=PR02
         raise NotImplementedError()
 
     @classmethod
-    def mexists(cls, uris: Iterable[ResourcePath]) -> dict[ResourcePath, bool]:
+    def mexists(
+        cls, uris: Iterable[ResourcePath], *, num_workers: int | None = None
+    ) -> dict[ResourcePath, bool]:
         """Check for existence of multiple URIs at once.
 
         Parameters
         ----------
         uris : iterable of `ResourcePath`
             The URIs to test.
+        num_workers : `int` or `None`, optional
+            The number of parallel workers to use when checking for existence
+            If `None`, the default value will be taken from the environment.
+            If this number is higher than the default and a thread pool is
+            used, there may not be enough cached connections available.
 
         Returns
         -------
@@ -906,27 +944,71 @@ class ResourcePath:  # numpydoc ignore=PR02
 
         existence: dict[ResourcePath, bool] = {}
         for uri_class in grouped:
-            existence.update(uri_class._mexists(grouped[uri_class]))
+            existence.update(uri_class._mexists(grouped[uri_class], num_workers=num_workers))
 
         return existence
 
     @classmethod
-    def _mexists(cls, uris: Iterable[ResourcePath]) -> dict[ResourcePath, bool]:
+    def _mexists(
+        cls, uris: Iterable[ResourcePath], *, num_workers: int | None = None
+    ) -> dict[ResourcePath, bool]:
         """Check for existence of multiple URIs at once.
 
         Implementation helper method for `mexists`.
 
+
+        Parameters
+        ----------
+        uris : iterable of `ResourcePath`
+            The URIs to test.
+        num_workers : `int` or `None`, optional
+            The number of parallel workers to use when checking for existence
+            If `None`, the default value will be taken from the environment.
+
+        Returns
+        -------
+        existence : `dict` of [`ResourcePath`, `bool`]
+            Mapping of original URI to boolean indicating existence.
+        """
+        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._mexists_pool(pool_executor_class, uris)
+        else:
+            return cls._mexists_pool(pool_executor_class, uris, num_workers=num_workers)
+
+    @classmethod
+    def _mexists_pool(
+        cls,
+        pool_executor_class: _EXECUTOR_TYPE,
+        uris: Iterable[ResourcePath],
+        *,
+        num_workers: int | None = None,
+    ) -> dict[ResourcePath, bool]:
+        """Check for existence of multiple URIs at once using specified pool
+        executor.
+
+        Implementation helper method for `_mexists`.
+
         Parameters
         ----------
+        pool_executor_class : `type` [ `concurrent.futures.Executor` ]
+            Type of executor pool to use.
         uris : iterable of `ResourcePath`
             The URIs to test.
+        num_workers : `int` or `None`, optional
+            The number of parallel workers to use when checking for existence
+            If `None`, the default value will be taken from the environment.
 
         Returns
         -------
         existence : `dict` of [`ResourcePath`, `bool`]
             Mapping of original URI to boolean indicating existence.
         """
-        with concurrent.futures.ThreadPoolExecutor(max_workers=_get_num_workers()) as exists_executor:
+        max_workers = num_workers if num_workers is not None else _get_num_workers()
+        with pool_executor_class(max_workers=max_workers) as exists_executor:
             future_exists = {exists_executor.submit(uri.exists): uri for uri in uris}
 
             results: dict[ResourcePath, bool] = {}
@@ -975,7 +1057,66 @@ class ResourcePath:  # numpydoc ignore=PR02
             A dict of all the transfer attempts with a value indicating
             whether the transfer succeeded for the target URI.
         """
-        with concurrent.futures.ThreadPoolExecutor(max_workers=_get_num_workers()) as transfer_executor:
+        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._mtransfer(
+                    pool_executor_class,
+                    transfer,
+                    from_to,
+                    overwrite=overwrite,
+                    transaction=transaction,
+                    do_raise=do_raise,
+                )
+        return cls._mtransfer(
+            pool_executor_class,
+            transfer,
+            from_to,
+            overwrite=overwrite,
+            transaction=transaction,
+            do_raise=do_raise,
+        )
+
+    @classmethod
+    def _mtransfer(
+        cls,
+        pool_executor_class: _EXECUTOR_TYPE,
+        transfer: str,
+        from_to: Iterable[tuple[ResourcePath, ResourcePath]],
+        overwrite: bool = False,
+        transaction: TransactionProtocol | None = None,
+        do_raise: bool = True,
+    ) -> dict[ResourcePath, MTransferResult]:
+        """Transfer many files in bulk.
+
+        Parameters
+        ----------
+        transfer : `str`
+            Mode to use for transferring the resource. Generically there are
+            many standard options: copy, link, symlink, hardlink, relsymlink.
+            Not all URIs support all modes.
+        from_to : `list` [ `tuple` [ `ResourcePath`, `ResourcePath` ] ]
+            A sequence of the source URIs and the target URIs.
+        overwrite : `bool`, optional
+            Allow an existing file to be overwritten. Defaults to `False`.
+        transaction : `~lsst.resources.utils.TransactionProtocol`, optional
+            A transaction object that can (depending on implementation)
+            rollback transfers on error.  Not guaranteed to be implemented.
+            The transaction object must be thread safe.
+        do_raise : `bool`, optional
+            If `True` an `ExceptionGroup` will be raised containing any
+            exceptions raised by the individual transfers. Else a dict
+            reporting the status of each `ResourcePath` will be returned.
+
+        Returns
+        -------
+        copy_status : `dict` [ `ResourcePath`, `MTransferResult` ]
+            A dict of all the transfer attempts with a value indicating
+            whether the transfer succeeded for the target URI.
+        """
+        with pool_executor_class(max_workers=_get_num_workers()) as transfer_executor:
             future_transfers = {
                 transfer_executor.submit(
                     to_uri.transfer_from,

lsst/resources/http.py

@@ -59,7 +59,7 @@ from lsst.utils.timer import time_this
 from ._resourceHandles import ResourceHandleProtocol
 from ._resourceHandles._httpResourceHandle import HttpReadResourceHandle, parse_content_range_header
 from ._resourcePath import ResourcePath
-from .utils import get_tempdir
+from .utils import _get_num_workers, get_tempdir
 
 if TYPE_CHECKING:
     from .utils import TransactionProtocol
@@ -165,14 +165,14 @@ class HttpResourcePathConfig:
         if self._front_end_connections is not None:
             return self._front_end_connections
 
+        default_pool_size = max(_get_num_workers(), self.DEFAULT_FRONTEND_PERSISTENT_CONNECTIONS)
+
         try:
             self._front_end_connections = int(
-                os.environ.get(
-                    "LSST_HTTP_FRONTEND_PERSISTENT_CONNECTIONS", self.DEFAULT_FRONTEND_PERSISTENT_CONNECTIONS
-                )
+                os.environ.get("LSST_HTTP_FRONTEND_PERSISTENT_CONNECTIONS", default_pool_size)
             )
         except ValueError:
-            self._front_end_connections = self.DEFAULT_FRONTEND_PERSISTENT_CONNECTIONS
+            self._front_end_connections = default_pool_size
 
         return self._front_end_connections
 
@@ -182,14 +182,14 @@ class HttpResourcePathConfig:
         if self._back_end_connections is not None:
             return self._back_end_connections
 
+        default_pool_size = max(_get_num_workers(), self.DEFAULT_FRONTEND_PERSISTENT_CONNECTIONS)
+
         try:
             self._back_end_connections = int(
-                os.environ.get(
-                    "LSST_HTTP_BACKEND_PERSISTENT_CONNECTIONS", self.DEFAULT_BACKEND_PERSISTENT_CONNECTIONS
-                )
+                os.environ.get("LSST_HTTP_BACKEND_PERSISTENT_CONNECTIONS", default_pool_size)
             )
         except ValueError:
-            self._back_end_connections = self.DEFAULT_BACKEND_PERSISTENT_CONNECTIONS
+            self._back_end_connections = default_pool_size
 
         return self._back_end_connections
 
@@ -587,7 +587,7 @@ class SessionStore:
         Note that "https://www.example.org" and "https://www.example.org:12345"
         will have different sessions since the port number is not identical.
         """
-        root_uri = str(rpath.root_uri())
+        root_uri = _dav_to_http(str(rpath.root_uri()))
         if root_uri not in self._sessions:
             # We don't have yet a session for this endpoint: create a new one.
             self._sessions[root_uri] = self._make_session(rpath)

lsst/resources/s3.py

@@ -220,7 +220,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 +232,7 @@ class S3ResourcePath(ResourcePath):
         for profile in profiles:
             getS3Client(profile)
 
-        return super()._mexists(uris)
+        return super()._mexists(uris, num_workers=num_workers)
 
     @backoff.on_exception(backoff.expo, retryable_io_errors, max_time=max_retry_time)
     def exists(self) -> bool:

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,11 @@ 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})
+    config = botocore.config.Config(
+        read_timeout=180,
+        max_pool_connections=_get_num_workers(),
+        retries={"mode": "adaptive", "max_attempts": 10},
+    )
 
     session = boto3.Session(profile_name=endpoint_config.profile)
 

lsst/resources/tests.py

@@ -1027,6 +1027,8 @@ class GenericReadWriteTestCase(_GenericTestCase):
         expected_files = {
             "dir1/a.yaml",
             "dir1/b.yaml",
+            "dir1/c.yaml",
+            "dir1/d.yaml",
             "dir2/e.yaml",
         }
         expected_uris = {root.join(f) for f in expected_files}
@@ -1035,7 +1037,8 @@ class GenericReadWriteTestCase(_GenericTestCase):
             self.assertTrue(uri.exists())
         expected_uris.add(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:

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.1600"
+__version__ = "29.2025.1800"

{lsst_resources-29.2025.1600.dist-info → lsst_resources-29.2025.1800.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-resources
-Version: 29.2025.1600
+Version: 29.2025.1800
 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

{lsst_resources-29.2025.1600.dist-info → lsst_resources-29.2025.1800.dist-info}/RECORD

@@ -1,28 +1,28 @@
 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/_resourcePath.py,sha256=DTsZTrCaXu9GLT1QwkhJaQcb-b8VuaRH1TU-J58PJ0M,70548
 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/http.py,sha256=9a_VadSabznPC0FTQtDtfV041zH25wZgXFtJ7HkvHp0,88275
 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/s3.py,sha256=X5ujR-w4LOJpOWAIBShn6hS0oeXQwvl3leeuj6c9LJ4,24198
+lsst/resources/s3utils.py,sha256=rhMvZjbHjymObDWsEUODoLaw70DrrJHn_cUi3G78VvI,14463
 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=DWDCyavYRMZByGPGMYcnpz6piNv1sQvCKH8yohX_F3c,55
+lsst/resources/tests.py,sha256=LZOxPfZhSS76z7s5kWuULaMlTo65_m8XROdHrQqubQQ,43646
+lsst/resources/utils.py,sha256=6O3Mq7JbPEtqyD2lM77pRpwcPMfV5SxiNMknw-F2vNs,8097
+lsst/resources/version.py,sha256=uRdffTNnwH4GQy77H1Wk3Md64craDCIuRxmCtF7ON0g,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/_httpResourceHandle.py,sha256=Yami8IVGeru4bLQCag-OvGG0ltz1qyEg57FY4IEB87Y,10995
 lsst/resources/_resourceHandles/_s3ResourceHandle.py,sha256=NkDmPb9bm_zMvr6mMnb-tBmqJDt0yUJrt2gZXR8l7ok,12923
-lsst_resources-29.2025.1600.dist-info/licenses/COPYRIGHT,sha256=yazVsoMmFwhiw5itGrdT4YPmXbpsQyUFjlpOyZIa77M,148
-lsst_resources-29.2025.1600.dist-info/licenses/LICENSE,sha256=7wrtgl8meQ0_RIuv2TjIKpAnNrl-ODH-QLwyHe9citI,1516
-lsst_resources-29.2025.1600.dist-info/METADATA,sha256=ZywINN9O-d4gZt7ZvEoR2kgBUJGEsB_mO0FIs6D2gvc,2237
-lsst_resources-29.2025.1600.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-lsst_resources-29.2025.1600.dist-info/top_level.txt,sha256=eUWiOuVVm9wwTrnAgiJT6tp6HQHXxIhj2QSZ7NYZH80,5
-lsst_resources-29.2025.1600.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-lsst_resources-29.2025.1600.dist-info/RECORD,,
+lsst_resources-29.2025.1800.dist-info/licenses/COPYRIGHT,sha256=yazVsoMmFwhiw5itGrdT4YPmXbpsQyUFjlpOyZIa77M,148
+lsst_resources-29.2025.1800.dist-info/licenses/LICENSE,sha256=7wrtgl8meQ0_RIuv2TjIKpAnNrl-ODH-QLwyHe9citI,1516
+lsst_resources-29.2025.1800.dist-info/METADATA,sha256=QUD23JcY-DYeGrrGfeFiZRUJ6dDpWuVeSu0YwW5HliI,2237
+lsst_resources-29.2025.1800.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
+lsst_resources-29.2025.1800.dist-info/top_level.txt,sha256=eUWiOuVVm9wwTrnAgiJT6tp6HQHXxIhj2QSZ7NYZH80,5
+lsst_resources-29.2025.1800.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+lsst_resources-29.2025.1800.dist-info/RECORD,,

{lsst_resources-29.2025.1600.dist-info → lsst_resources-29.2025.1800.dist-info}/WHEEL

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