Propagate fragments with ResourcePath.join

Previously fragments were either dropped completely (if a
ResourcePath was given that had a fragment) or included in the
file name (if a plain string was given).

Now fragments are always propagated if the ResourcePath parsing
finds a fragment. This means that if a filename has a "#" in it
that "#" will now always be treated as a fragment and not part
of the filename.

Author: timj

python/lsst/resources/_resourcePath.py

@@ -693,7 +693,7 @@ def join(
             quoted depending on the associated URI scheme. If the path looks
             like a URI referring to an absolute location, it will be returned
             directly (matching the behavior of `os.path.join`). It can
-            also be a `ResourcePath`.
+            also be a `ResourcePath`. Fragments are propagated.
         isTemporary : `bool`, optional
             Indicate that the resulting URI represents a temporary resource.
             Default is ``self.isTemporary``.
@@ -723,6 +723,9 @@ def join(
         refer to a file. Use `updatedFile` if the file is to be
         replaced.
 
+        If an unquoted ``#`` is included in the path it is assumed to be
+        referring to a fragment and not part of the file name.
+
         Raises
         ------
         ValueError
@@ -757,10 +760,10 @@ def join(
             # Absolute URI so return it directly.
             return path_uri
 
-        # If this was originally a ResourcePath extract the unquoted path from
-        # it. Otherwise we use the string we were given to allow "#" to appear
-        # in the filename if given as a plain string.
-        if not isinstance(path, str):
+        # We want to propagate fragments to the joined path and we rely on
+        # the ResourcePath parser to find these fragments for us even in plain
+        # strings. Must assume there are no `#` characters in filenames.
+        if not isinstance(path, str) or path_uri.fragment:
             path = path_uri.unquoted_path
 
         # Might need to quote the path.
@@ -780,6 +783,7 @@ def join(
             path=newpath,
             forceDirectory=forceDirectory,
             isTemporary=isTemporary,
+            fragment=path_uri.fragment,
         )
 
     def relative_to(self, other: ResourcePath) -> str | None:

python/lsst/resources/tests.py

@@ -474,9 +474,22 @@ def test_join(self) -> None:
         self.assertFalse(up_relative.isdir())
         self.assertEqual(up_relative.geturl(), f"{root_str}b/c.txt")
 
+        # Check that fragment is passed through join (simple unquoted case).
+        fnew3 = root.join("a/b.txt#fragment")
+        self.assertEqual(fnew3.fragment, "fragment")
+        self.assertEqual(fnew3.basename(), "b.txt", msg=f"Got: {fnew3._uri}")
+
+        # Join a resource path.
+        subpath = ResourcePath("a/b.txt#fragment2", forceAbsolute=False, forceDirectory=False)
+        fnew3 = root.join(subpath)
+        self.assertEqual(fnew3.fragment, "fragment2")
+        self.assertEqual(fnew3.basename(), "b.txt", msg=f"Got: {fnew3._uri}")
+
+        # Quoted string with fragment.
         quote_example = "hsc/payload/b&c.t@x#t"
         needs_quote = root.join(quote_example)
-        self.assertEqual(needs_quote.unquoted_path, "/" + quote_example)
+        self.assertEqual(needs_quote.unquoted_path, "/" + quote_example[:-2])
+        self.assertEqual(needs_quote.fragment, "t")
 
         other = ResourcePath(f"{self.root}test.txt")
         self.assertEqual(root.join(other), other)