lsst-resources 29.2025.4800__tar.gz → 30.0.0__tar.gz

{lsst_resources-29.2025.4800/python/lsst_resources.egg-info → lsst_resources-30.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-resources
-Version: 29.2025.4800
+Version: 30.0.0
 Summary: An abstraction layer for reading and writing from URI file resources.
 Author-email: Rubin Observatory Data Management <dm-admin@lists.lsst.org>
 License-Expression: BSD-3-Clause

{lsst_resources-29.2025.4800 → lsst_resources-30.0.0}/doc/lsst.resources/CHANGES.rst

@@ -1,3 +1,33 @@
+Resources v30.0.0 (2026-01-15)
+==============================
+
+New Features
+------------
+
+- Added ``walk_up`` parameter to ``ResourcePath.relative_to`` to match the behavior of ``Path.relative_to``.
+  Using ``walk_up=True`` allows ``..`` to be present in the returned string.
+  The default is `False` to remain compatible with previous versions.
+  This parameter can only be `True` for Python 3.12 and newer. (`DM-41256 <https://rubinobs.atlassian.net/browse/DM-41256>`_)
+- Added ``eups:`` URI scheme.
+  This scheme will use the EUPS ``$<PRODUCT>_DIR`` environment variables if set, else try to find the corresponding Python package and look for a ``resources`` directory inside it following the decisions made in `RFC-1090 <https://rubinobs.atlassian.net/browse/RFC-1090>`_.
+  Additionally, if a URI starts with ``$PRODUCT_DIR`` it is automatically converted to an EUPS URI. (`DM-50997 <https://rubinobs.atlassian.net/browse/DM-50997>`_)
+
+
+Bug Fixes
+---------
+
+- Fixed ``ResourcePath.write`` for schemeless URIs that had no directory component. (`DM-41256 <https://rubinobs.atlassian.net/browse/DM-41256>`_)
+- Fixed an issue where ``S3ResourcePath.transfer_from(S3ResourcePath)`` would fail when the source and destination were using different S3 endpoints or sets of credentials. (`DM-51384 <https://rubinobs.atlassian.net/browse/DM-51384>`_)
+- Two simultaneous copies without overwrite could both succeed in certain cases.
+  This race condition has now been eliminated. (`DM-51540 <https://rubinobs.atlassian.net/browse/DM-51540>`_)
+
+
+Miscellaneous Changes of Minor Interest
+---------------------------------------
+
+- Fixed bug where ``.parents()`` and ``.dirname()`` were incorrectly returning the fragment of the file. (`DM-51890 <https://rubinobs.atlassian.net/browse/DM-51890>`_)
+
+
 Resources v29.1.0 (2025-06-13)
 ==============================
 

{lsst_resources-29.2025.4800 → lsst_resources-30.0.0}/python/lsst/resources/_resourcePath.py

@@ -386,6 +386,11 @@ class ResourcePath:  # numpydoc ignore=PR02
                 from .mem import InMemoryResourcePath
 
                 subclass = InMemoryResourcePath
+            elif parsed.scheme == "eups":
+                # EUPS package root.
+                from .eups import EupsResourcePath
+
+                subclass = EupsResourcePath
             else:
                 raise NotImplementedError(
                     f"No URI support for scheme: '{parsed.scheme}' in {parsed.geturl()}"
@@ -396,11 +401,15 @@ class ResourcePath:  # numpydoc ignore=PR02
             )
 
             # It is possible for the class to change from schemeless
-            # to file so handle that
+            # to file or eups so handle that
             if parsed.scheme == "file":
                 from .file import FileResourcePath
 
                 subclass = FileResourcePath
+            elif parsed.scheme == "eups":
+                from .eups import EupsResourcePath
+
+                subclass = EupsResourcePath
 
         # Now create an instance of the correct subclass and set the
         # attributes directly
@@ -410,8 +419,13 @@ class ResourcePath:  # numpydoc ignore=PR02
         if isTemporary is None:
             isTemporary = False
         self.isTemporary = isTemporary
+        self._set_proxy()
         return self
 
+    def _set_proxy(self) -> None:
+        """Calculate internal proxy for externally visible resource path."""
+        pass
+
     @property
     def scheme(self) -> str:
         """Return the URI scheme.

lsst_resources-30.0.0/python/lsst/resources/eups.py

@@ -0,0 +1,101 @@
+# This file is part of lsst-resources.
+#
+# Developed for the LSST Data Management System.
+# This product includes software developed by the LSST Project
+# (https://www.lsst.org).
+# See the COPYRIGHT file at the top-level directory of this distribution
+# for details of code ownership.
+#
+# Use of this source code is governed by a 3-clause BSD-style
+# license that can be found in the LICENSE file.
+
+from __future__ import annotations
+
+__all__ = ("EupsResourcePath",)
+
+import logging
+import posixpath
+import urllib.parse
+
+from lsst.utils import getPackageDir
+
+from ._resourcePath import ResourcePath
+from .proxied import ProxiedResourcePath
+from .utils import os2posix
+
+log = logging.getLogger(__name__)
+
+
+class EupsResourcePath(ProxiedResourcePath):
+    """URI referring to an EUPS package.
+
+    These URIs look like: ``eups://daf_butler/configs/file.yaml``
+    where the network location is the EUPS package name.
+
+    Internally they are proxied by either ``file`` URIs or ``resource`` URIs.
+    If an ``{product}_DIR`` environment variable is found it will be used
+    and internally a ``file`` URI will be created. If no environment variable
+    is found an attempt will be made to convert the EUPS product name to
+    a python package and a ``resource`` URI will be returned with
+    ``/resources`` appended. The convention is that any package supporting
+    an EUPS URI outside an EUPS environment will also have made available
+    the support files as package resources.
+
+    If it is known that the package supports package resources it is always
+    better to use that URI form explicitly since it is more robust since
+    not all EUPS packages can reliably be converted to python packages
+    without EUPS.
+    """
+
+    quotePaths = False
+    _proxy: ResourcePath | None = None
+    _default_namespace: str = "lsst"
+
+    def _set_proxy(self) -> None:
+        """Calculate the internal `ResourcePath` corresponding to the public
+        version.
+        """
+        # getPackageDir returns an absolute path.
+        try:
+            eups_path = getPackageDir(self.netloc)
+            log.debug("Found EUPS package %s via env var", self.netloc)
+        except LookupError:
+            eups_path = ""
+        if eups_path:
+            # Must convert this path into a file URI.
+            new_path = posixpath.join(os2posix(eups_path), os2posix(self.path.lstrip("/")))
+            parsed = self._uri._replace(path=urllib.parse.quote(new_path), scheme="file", netloc="")
+            self._proxy = ResourcePath(parsed)
+            return
+
+        # If there is no _DIR env var we need to look for python package
+        # resource. There is no guaranteed way to generated a python package
+        # from an EUPS product name.
+        # daf_butler -> lsst.daf.butler
+        # image_cutout_backend -> lsst.image_cutout_backend
+        # astro_metadata_translator -> astro_metadata_translator
+        product = self.netloc
+        variants = (
+            product,
+            self._default_namespace + "." + product.replace("_", "."),
+            self._default_namespace + "." + product,
+            product.replace("_", "."),
+        )
+        for variant in variants:
+            proxy = ResourcePath(f"resource://{variant}/resources", forceDirectory=True)
+            # This can be slow because package imports happen but there is
+            # no other way to check that we have the correct variant.
+            log.debug("Trying variant %s", proxy)
+            if proxy.exists():
+                self._proxy = proxy
+                if self.path:
+                    self._proxy = self._proxy.join(self.path.lstrip("/"))
+                log.debug(f"Found variant {variant}")
+                return
+
+        # Can not find an actively set up package or resources for this EUPS
+        # product. Return without setting a proxy to allow standard URI
+        # path manipulations to happen but defer failure until someone tries
+        # to use the proxy for read.
+        log.debug("Could not find any files corresponding to %s", self)
+        return

{lsst_resources-29.2025.4800 → lsst_resources-30.0.0}/python/lsst/resources/packageresource.py

@@ -42,6 +42,8 @@ class PackageResourcePath(ResourcePath):
     resource name.
     """
 
+    quotePaths = False
+
     def _get_ref(self) -> resources.abc.Traversable | None:
         """Obtain the object representing the resource.
 

lsst_resources-30.0.0/python/lsst/resources/proxied.py

@@ -0,0 +1,148 @@
+# This file is part of lsst-resources.
+#
+# Developed for the LSST Data Management System.
+# This product includes software developed by the LSST Project
+# (https://www.lsst.org).
+# See the COPYRIGHT file at the top-level directory of this distribution
+# for details of code ownership.
+#
+# Use of this source code is governed by a 3-clause BSD-style
+# license that can be found in the LICENSE file.
+
+from __future__ import annotations
+
+__all__ = ("ProxiedResourcePath",)
+
+import contextlib
+import logging
+import re
+from abc import ABC, abstractmethod
+from collections.abc import Iterator
+
+from ._resourcePath import ResourceHandleProtocol, ResourcePath, ResourcePathExpression
+from .utils import TransactionProtocol
+
+try:
+    import fsspec
+    from fsspec.spec import AbstractFileSystem
+except ImportError:
+    fsspec = None
+    AbstractFileSystem = type
+
+
+log = logging.getLogger(__name__)
+
+
+class ProxiedResourcePath(ABC, ResourcePath):
+    """URI that is represented internally by another type of URI for file I/O.
+
+    For example ``abc://xyz/file.txt`` could be the public URI form but
+    internally all file access is forwarded to a ``file`` URI.
+    """
+
+    _proxy: ResourcePath | None = None
+
+    @abstractmethod
+    def _set_proxy(self) -> None:
+        """Calculate the internal `ResourcePath` corresponding to the public
+        version.
+        """
+        raise NotImplementedError("Proxy must be configured")
+
+    def _get_proxy(self) -> ResourcePath:
+        """Retrieve the proxied ResourcePath."""
+        proxy = self._proxy
+        if proxy is None:
+            raise FileNotFoundError(f"Internal error: No proxy ResourcePath available for {self}")
+        return proxy
+
+    def to_fsspec(self) -> tuple[AbstractFileSystem, str]:
+        try:
+            proxy = self._get_proxy()
+        except FileNotFoundError:
+            raise NotImplementedError(f"No proxy registered for {self}. Resource does not exist.") from None
+        return proxy.to_fsspec()
+
+    def isdir(self) -> bool:
+        if self.dirLike is None:
+            try:
+                proxy = self._get_proxy()
+            except FileNotFoundError:
+                return False
+            self.dirLike = proxy.isdir()
+        return self.dirLike
+
+    def exists(self) -> bool:
+        try:
+            proxy = self._get_proxy()
+        except FileNotFoundError:
+            # If there is no proxy registered then the resource can not exist.
+            return False
+        return proxy.exists()
+
+    def remove(self) -> None:
+        proxy = self._get_proxy()
+        proxy.remove()
+
+    def read(self, size: int = -1) -> bytes:
+        proxy = self._get_proxy()
+        return proxy.read(size=size)
+
+    @contextlib.contextmanager
+    def as_local(
+        self, multithreaded: bool = True, tmpdir: ResourcePathExpression | None = None
+    ) -> Iterator[ResourcePath]:
+        proxy = self._get_proxy()
+        with proxy.as_local(multithreaded=multithreaded, tmpdir=tmpdir) as loc:
+            yield loc
+
+    @contextlib.contextmanager
+    def open(
+        self,
+        mode: str = "r",
+        *,
+        encoding: str | None = None,
+        prefer_file_temporary: bool = False,
+    ) -> Iterator[ResourceHandleProtocol]:
+        proxy = self._get_proxy()
+        with proxy.open(mode, encoding=encoding, prefer_file_temporary=prefer_file_temporary) as fh:
+            yield fh
+
+    def walk(
+        self, file_filter: str | re.Pattern | None = None
+    ) -> Iterator[list | tuple[ResourcePath, list[str], list[str]]]:
+        try:
+            proxy = self._get_proxy()
+        except FileNotFoundError as e:
+            raise ValueError(str(e)) from None
+        for proxied_root, dirs, files in proxy.walk(file_filter=file_filter):
+            # Need to return the directory in the original form and not the
+            # proxy form.
+            relative_to_self = proxied_root.path.removeprefix(proxy.path)
+            root = self.replace(path=self._pathModule.join(self.path, relative_to_self))
+            yield root, dirs, files
+
+    def size(self) -> int:
+        proxy = self._get_proxy()
+        return proxy.size()
+
+    def write(self, data: bytes, overwrite: bool = True) -> None:
+        proxy = self._get_proxy()
+        proxy.write(data, overwrite=overwrite)
+
+    def mkdir(self) -> None:
+        proxy = self._get_proxy()
+        proxy.mkdir()
+
+    def transfer_from(
+        self,
+        src: ResourcePath,
+        transfer: str = "copy",
+        overwrite: bool = False,
+        transaction: TransactionProtocol | None = None,
+        multithreaded: bool = True,
+    ) -> None:
+        proxy = self._get_proxy()
+        proxy.transfer_from(
+            src, transfer=transfer, overwrite=overwrite, transaction=transaction, multithreaded=multithreaded
+        )

{lsst_resources-29.2025.4800 → lsst_resources-30.0.0}/python/lsst/resources/schemeless.py

@@ -16,6 +16,7 @@ __all__ = ("SchemelessResourcePath",)
 import logging
 import os
 import os.path
+import re
 import stat
 import urllib.parse
 from pathlib import PurePath
@@ -211,12 +212,23 @@ class SchemelessResourcePath(FileResourcePath):
         expandedPath = os.path.expanduser(urllib.parse.unquote(parsed.path))
 
         # We might also be receiving a path containing environment variables
-        # so expand those here
+        # so expand those here, although we treat $X_DIR at the start of the
+        # path as a special EUPS URI. This allows us to handle EUPS-style
+        # env var specifications even if EUPS has not set them.
+        # Support $X_DIR and ${X_DIR} variants at the start of the path.
+        if eups := re.match(r"(\$\{?([A-Z_]+)_DIR\}?)/", expandedPath):
+            replacements["scheme"] = "eups"
+            # Two matching groups: the entire env var, and the EUPS product.
+            replacements["netloc"] = eups.group(2).lower()
+            expandedPath = expandedPath.removeprefix(eups.group(1))
+
         expandedPath = os.path.expandvars(expandedPath)
 
-        # Ensure that this becomes a file URI if it is already absolute
+        # Ensure that this becomes a file URI if it is already absolute, unless
+        # we already overrode it above.
         if os.path.isabs(expandedPath):
-            replacements["scheme"] = "file"
+            if "scheme" not in replacements:
+                replacements["scheme"] = "file"
             # Keep in OS form for now to simplify later logic
             replacements["path"] = os.path.normpath(expandedPath)
         elif forceAbsolute:
@@ -265,9 +277,9 @@ class SchemelessResourcePath(FileResourcePath):
             if not replacements["path"].endswith(os.sep):
                 replacements["path"] += os.sep
 
-        if "scheme" in replacements:
+        if "scheme" in replacements and replacements["scheme"] == "file":
             # This is now meant to be a URI path so force to posix
-            # and quote
+            # and quote. EUPS URIs are not quoted.
             replacements["path"] = urllib.parse.quote(os2posix(replacements["path"]))
 
         # ParseResult is a NamedTuple so _replace is standard API

{lsst_resources-29.2025.4800 → lsst_resources-30.0.0}/python/lsst/resources/tests.py

@@ -417,11 +417,19 @@ class GenericTestCase(_GenericTestCase):
     def test_escapes(self) -> None:
         """Special characters in file paths."""
         src = self.root_uri.join("bbb/???/test.txt")
-        self.assertNotIn("???", src.path)
+        quotes = src.quotePaths
+
+        if quotes:
+            self.assertNotIn("???", src.path)
+        else:
+            self.assertIn("???", src.path)
         self.assertIn("???", src.unquoted_path)
 
         file = src.updatedFile("tests??.txt")
-        self.assertNotIn("??.txt", file.path)
+        if quotes:
+            self.assertNotIn("??.txt", file.path)
+        else:
+            self.assertIn("??.txt", file.path)
 
         src = src.updatedFile("tests??.txt")
         self.assertIn("??.txt", src.unquoted_path)
@@ -456,7 +464,10 @@ class GenericTestCase(_GenericTestCase):
 
         fnew2 = fdir.join(new2name)
         self.assertTrue(fnew2.unquoted_path.endswith(new2name))
-        self.assertNotIn("###", fnew2.path)
+        if quotes:
+            self.assertNotIn("###", fnew2.path)
+        else:
+            self.assertIn("###", fnew2.path)
 
         # Test that children relative to schemeless and file schemes
         # still return the same unquoted name

lsst_resources-30.0.0/python/lsst/resources/version.py

@@ -0,0 +1,2 @@
+__all__ = ["__version__"]
+__version__ = "30.0.0"

{lsst_resources-29.2025.4800 → lsst_resources-30.0.0/python/lsst_resources.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-resources
-Version: 29.2025.4800
+Version: 30.0.0
 Summary: An abstraction layer for reading and writing from URI file resources.
 Author-email: Rubin Observatory Data Management <dm-admin@lists.lsst.org>
 License-Expression: BSD-3-Clause

{lsst_resources-29.2025.4800 → lsst_resources-30.0.0}/python/lsst_resources.egg-info/SOURCES.txt

@@ -14,12 +14,14 @@ python/lsst/resources/__init__.py
 python/lsst/resources/_resourcePath.py
 python/lsst/resources/dav.py
 python/lsst/resources/davutils.py
+python/lsst/resources/eups.py
 python/lsst/resources/file.py
 python/lsst/resources/gs.py
 python/lsst/resources/http.py
 python/lsst/resources/location.py
 python/lsst/resources/mem.py
 python/lsst/resources/packageresource.py
+python/lsst/resources/proxied.py
 python/lsst/resources/py.typed
 python/lsst/resources/s3.py
 python/lsst/resources/s3utils.py
@@ -40,6 +42,7 @@ python/lsst_resources.egg-info/requires.txt
 python/lsst_resources.egg-info/top_level.txt
 python/lsst_resources.egg-info/zip-safe
 tests/test_dav.py
+tests/test_eups.py
 tests/test_file.py
 tests/test_gs.py
 tests/test_http.py

lsst_resources-30.0.0/tests/test_eups.py

@@ -0,0 +1,239 @@
+# This file is part of lsst-resources.
+#
+# Developed for the LSST Data Management System.
+# This product includes software developed by the LSST Project
+# (https://www.lsst.org).
+# See the COPYRIGHT file at the top-level directory of this distribution
+# for details of code ownership.
+#
+# Use of this source code is governed by a 3-clause BSD-style
+# license that can be found in the LICENSE file.
+
+import os
+import re
+import sys
+import unittest
+import unittest.mock
+
+from lsst.resources import ResourcePath
+from lsst.resources.eups import EupsResourcePath
+from lsst.resources.tests import GenericTestCase
+
+TESTDIR = os.path.abspath(os.path.dirname(__file__))
+PKG_DIR = os.path.join(TESTDIR, "packages", "eups")
+PACKAGE_PATH = os.path.join(TESTDIR, "packages")
+
+
+class EupsTestCase(GenericTestCase, unittest.TestCase):
+    """Generic test of resource URIs."""
+
+    scheme = "eups"
+    netloc = "pkg"
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        # The actual value does not matter for these tests.
+        os.environ["PKG_DIR"] = PKG_DIR
+        super().setUpClass()
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        del os.environ["PKG_DIR"]
+        super().tearDownClass()
+
+    def test_relative(self) -> None:
+        # This test uses two additional netlocs which need corresponding
+        # environment variables to function. The values do not matter.
+        with unittest.mock.patch.dict(os.environ, {"OTHER_DIR": "x", "MY.HOST_DIR": "y"}):
+            super().test_relative()
+
+
+class EupsReadTestCase(unittest.TestCase):
+    """Test that EUPS information can be read.
+
+    EUPS resources can be thought of as being read only even if the
+    underlying URI is a ``file`` URI.
+    """
+
+    scheme = "eups"
+    netloc = "pkg"
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        # The actual value does not matter for these tests.
+        os.environ["PKG_DIR"] = PKG_DIR
+        super().setUpClass()
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        del os.environ["PKG_DIR"]
+        super().tearDownClass()
+
+    def setUp(self):
+        self.root = f"{self.scheme}://{self.netloc}"
+        self.root_uri = ResourcePath(self.root)
+
+    def test_read(self):
+        uri = self.root_uri.join("config/test.txt")
+        self.assertTrue(uri.exists(), f"Check {uri} exists")
+
+        content = uri.read().decode()
+        self.assertIn("A test config.", content)
+
+        with uri.as_local() as local_uri:
+            self.assertEqual(local_uri.scheme, "file")
+            self.assertTrue(local_uri.exists())
+
+        truncated = uri.read(size=9).decode()
+        self.assertEqual(truncated, content[:9])
+
+        # Check that directory determination can work directly without the
+        # trailing slash.
+        d = self.root_uri.join("config")
+        self.assertTrue(d.isdir())
+        self.assertTrue(d.dirLike)
+
+        d = self.root_uri.join("config/", forceDirectory=True)
+        self.assertTrue(d.exists(), f"Check directory {d} exists")
+        self.assertTrue(d.isdir())
+
+        with self.assertRaises(IsADirectoryError):
+            with d.as_local() as local_uri:
+                pass
+
+        j = d.join("test.txt")
+        self.assertEqual(uri, j)
+        self.assertFalse(j.dirLike)
+        self.assertFalse(j.isdir())
+        not_there = d.join("not-there.yaml")
+        self.assertFalse(not_there.exists())
+
+        bad = ResourcePath(f"{self.scheme}://bad.module/not.yaml")
+        multi = ResourcePath.mexists([uri, bad, not_there])
+        self.assertTrue(multi[uri])
+        self.assertFalse(multi[bad])
+        self.assertFalse(multi[not_there])
+
+        # Check that the bad URI works as expected.
+        self.assertFalse(bad.exists())
+        self.assertFalse(bad.isdir())
+        with self.assertRaises(FileNotFoundError):
+            bad.read()
+        with self.assertRaises(FileNotFoundError):
+            with bad.as_local():
+                pass
+        with self.assertRaises(FileNotFoundError):
+            with bad.open("r"):
+                pass
+
+        # fsspec is always not implemented.
+        with self.assertRaises(NotImplementedError):
+            bad.to_fsspec()
+
+    def test_open(self):
+        uri = self.root_uri.join("config/test.txt")
+        with uri.open("rb") as buffer:
+            content = buffer.read()
+        self.assertEqual(uri.read(), content)
+
+        with uri.open("r") as buffer:
+            content = buffer.read()
+        self.assertEqual(uri.read().decode(), content)
+
+    def test_walk(self):
+        """Test that we can find file resources.
+
+        Try to find resources in this package. Python does not care whether
+        a resource is a Python file or anything else.
+        """
+        resource = ResourcePath(f"{self.scheme}://{self.netloc}/")
+        resources = set(ResourcePath.findFileResources([resource]))
+
+        # Do not try to list all possible options. Files can move around
+        # and cache files can appear.
+        subset = {
+            ResourcePath(f"{self.scheme}://{self.netloc}/config/test.txt"),
+            ResourcePath(f"{self.scheme}://{self.netloc}/config/test2.yaml"),
+        }
+        for r in subset:
+            self.assertIn(r, resources)
+
+        resources = set(
+            ResourcePath.findFileResources(
+                [ResourcePath(f"{self.scheme}://{self.netloc}/")], file_filter=r".*\.json"
+            )
+        )
+        self.assertEqual(resources, set())
+
+        # Compare regex with str.
+        regex = r".*\.yaml"
+        y_files_str = list(resource.walk(file_filter=regex))
+        y_files_re = list(resource.walk(file_filter=re.compile(regex)))
+        self.assertGreater(len(y_files_str), 1)
+        self.assertEqual(y_files_str, y_files_re)
+
+        bad_dir = ResourcePath(f"{self.scheme}://bad.module/a/dir/")
+        self.assertTrue(bad_dir.isdir())
+        with self.assertRaises(ValueError):
+            list(bad_dir.walk())
+
+    def test_env_var(self):
+        """Test that environment variables are converted."""
+        with unittest.mock.patch.dict(os.environ, {"MY_TEST_DIR": TESTDIR}):
+            for env_string in ("$MY_TEST_DIR", "${MY_TEST_DIR}"):
+                uri = ResourcePath(f"{env_string}/data/dir1/a.yaml")
+                self.assertEqual(uri.path, "/data/dir1/a.yaml")
+                self.assertEqual(uri.scheme, "eups")
+                self.assertEqual(uri.netloc, "my_test")
+                self.assertTrue(uri.exists())
+
+
+class EupsAsResourcesReadTestCase(EupsReadTestCase):
+    """Test that EUPS information can be read via resources.
+
+    EUPS resources can be thought of as being read only even if the
+    underlying URI is a ``file`` URI.
+    """
+
+    scheme = "eups"
+    netloc = "pkg1"
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        # The actual value does not matter for these tests.
+        sys.path.append(PACKAGE_PATH)
+        super().setUpClass()
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        sys.path.remove(PACKAGE_PATH)
+        super().tearDownClass()
+
+
+class EupsAsResourcesReadTestCase2(EupsAsResourcesReadTestCase):
+    """Test that EUPS information can be read via resources with lsst-style
+    package.
+
+    EUPS resources can be thought of as being read only even if the
+    underlying URI is a ``file`` URI.
+    """
+
+    scheme = "eups"
+    netloc = "pkg2_sub"
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        # To avoid confusion with other lsst packages, override the default
+        # prefix that is added to the EUPS name.
+        cls.prefix = EupsResourcePath._default_namespace
+        EupsResourcePath._default_namespace = "prefix"
+        super().setUpClass()
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        EupsResourcePath._default_namespace = cls.prefix
+        super().tearDownClass()
+
+
+if __name__ == "__main__":
+    unittest.main()

{lsst_resources-29.2025.4800 → lsst_resources-30.0.0}/tests/test_file.py

@@ -46,14 +46,14 @@ class FileTestCase(GenericTestCase, unittest.TestCase):
 
     def test_env_var(self):
         """Test that environment variables are expanded."""
-        with unittest.mock.patch.dict(os.environ, {"MY_TEST_DIR": "/a/b/c"}):
-            uri = ResourcePath("${MY_TEST_DIR}/d.txt")
+        with unittest.mock.patch.dict(os.environ, {"MY_TEST_DIRX": "/a/b/c"}):
+            uri = ResourcePath("${MY_TEST_DIRX}/d.txt")
         self.assertEqual(uri.path, "/a/b/c/d.txt")
         self.assertEqual(uri.scheme, "file")
 
         # This will not expand
-        uri = ResourcePath("${MY_TEST_DIR}/d.txt", forceAbsolute=False)
-        self.assertEqual(uri.path, "${MY_TEST_DIR}/d.txt")
+        uri = ResourcePath("${MY_TEST_DIRX}/d.txt", forceAbsolute=False)
+        self.assertEqual(uri.path, "${MY_TEST_DIRX}/d.txt")
         self.assertFalse(uri.scheme)
 
     def test_ospath(self):

{lsst_resources-29.2025.4800 → lsst_resources-30.0.0}/tests/test_s3.py

@@ -224,6 +224,9 @@ class S3ReadWriteTestCaseBase(GenericReadWriteTestCase):
     def test_implicit_default_threading(self):
         S3ResourcePath.use_threads = None
         boto_default = signature(boto3.s3.transfer.TransferConfig).parameters["use_threads"].default
+        # Newer versions of boto return None as the default.
+        if boto_default is None:
+            boto_default = True
         test_resource_path = self.root_uri.join("test_file.dat")
         self.assertEqual(test_resource_path._transfer_config.use_threads, boto_default)
 
@@ -231,6 +234,9 @@ class S3ReadWriteTestCaseBase(GenericReadWriteTestCase):
         with mock.patch.dict(os.environ, {"LSST_S3_USE_THREADS": "None"}):
             S3ResourcePath.use_threads = None
             boto_default = signature(boto3.s3.transfer.TransferConfig).parameters["use_threads"].default
+            # Newer versions of boto return None as the default.
+            if boto_default is None:
+                boto_default = True
             test_resource_path = self.root_uri.join("test_file.dat")
             self.assertEqual(test_resource_path._transfer_config.use_threads, boto_default)
 

lsst_resources-29.2025.4800/python/lsst/resources/version.py

@@ -1,2 +0,0 @@
-__all__ = ["__version__"]
-__version__ = "29.2025.4800"