lsst-daf-butler 29.2025.2900__tar.gz → 29.2025.3100__tar.gz

{lsst_daf_butler-29.2025.2900/python/lsst_daf_butler.egg-info → lsst_daf_butler-29.2025.3100}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-daf-butler
-Version: 29.2025.2900
+Version: 29.2025.3100
 Summary: An abstraction layer for reading and writing astronomical data to datastores.
 Author-email: Rubin Observatory Data Management <dm-admin@lists.lsst.org>
 License: BSD 3-Clause License

{lsst_daf_butler-29.2025.2900 → lsst_daf_butler-29.2025.3100}/python/lsst/daf/butler/_butler.py

@@ -347,13 +347,13 @@ class Butler(LimitedButler):  # numpydoc ignore=PR02
                     without_datastore=without_datastore,
                 )
             case ButlerType.REMOTE:
-                from .remote_butler import RemoteButlerFactory
+                from .remote_butler._factory import RemoteButlerFactory
 
                 # Assume this is being created by a client who would like
                 # default caching of remote datasets.
                 factory = RemoteButlerFactory.create_factory_from_config(butler_config)
                 return factory.create_butler_with_credentials_from_environment(
-                    butler_options=options, use_disabled_datastore_cache=False
+                    butler_options=options, enable_datastore_cache=True
                 )
             case _:
                 raise TypeError(f"Unknown Butler type '{butler_type}'")

{lsst_daf_butler-29.2025.2900 → lsst_daf_butler-29.2025.3100}/python/lsst/daf/butler/_labeled_butler_factory.py

@@ -198,9 +198,9 @@ def _create_direct_butler_factory(config: ButlerConfig, preload_unsafe_caches: b
 
 
 def _create_remote_butler_factory(config: ButlerConfig) -> _FactoryFunction:
-    import lsst.daf.butler.remote_butler
+    import lsst.daf.butler.remote_butler._factory
 
-    factory = lsst.daf.butler.remote_butler.RemoteButlerFactory.create_factory_from_config(config)
+    factory = lsst.daf.butler.remote_butler._factory.RemoteButlerFactory.create_factory_from_config(config)
 
     def create_butler(access_token: str | None) -> Butler:
         if access_token is None:

{lsst_daf_butler-29.2025.2900 → lsst_daf_butler-29.2025.3100}/python/lsst/daf/butler/datastore/_datastore.py

@@ -66,8 +66,8 @@ if TYPE_CHECKING:
     from .._dataset_ref import DatasetId, DatasetRef
     from .._dataset_type import DatasetType
     from .._storage_class import StorageClass
+    from ..datastores.file_datastore.get import DatasetLocationInformation
     from ..datastores.file_datastore.retrieve_artifacts import ArtifactIndexInfo
-    from ..datastores.fileDatastoreClient import FileDatastoreGetPayload
     from ..registry.interfaces import DatasetIdRef, DatastoreRegistryBridgeManager
     from .record_data import DatastoreRecordData
     from .stored_file_info import StoredDatastoreItemInfo
@@ -614,8 +614,8 @@ class Datastore(FileTransferSource, metaclass=ABCMeta):
         """
         raise NotImplementedError("Must be implemented by subclass")
 
-    def prepare_get_for_external_client(self, ref: DatasetRef) -> FileDatastoreGetPayload | None:
-        """Retrieve serializable data that can be used to execute a ``get()``.
+    def prepare_get_for_external_client(self, ref: DatasetRef) -> list[DatasetLocationInformation] | None:
+        """Retrieve data that can be used to execute a ``get()``.
 
         Parameters
         ----------
@@ -624,11 +624,9 @@ class Datastore(FileTransferSource, metaclass=ABCMeta):
 
         Returns
         -------
-        payload : `object` | `None`
-            Serializable payload containing the information needed to perform a
-            get() operation.  This payload may be sent over the wire to another
-            system to perform the get().  Returns `None` if the dataset is not
-            known to this datastore.
+        payload : `list` [ `DatasetLocationInformation` ] | `None`
+            Information needed to perform a get() operation.  Returns `None` if
+            the dataset is not known to this datastore.
         """
         raise NotImplementedError()
 

{lsst_daf_butler-29.2025.2900 → lsst_daf_butler-29.2025.3100}/python/lsst/daf/butler/datastores/chainedDatastore.py

@@ -47,6 +47,7 @@ from lsst.daf.butler.datastore import (
 )
 from lsst.daf.butler.datastore.constraints import Constraints
 from lsst.daf.butler.datastore.record_data import DatastoreRecordData
+from lsst.daf.butler.datastores.file_datastore.get import DatasetLocationInformation
 from lsst.daf.butler.datastores.file_datastore.retrieve_artifacts import ArtifactIndexInfo, ZipIndex
 from lsst.resources import ResourcePath
 from lsst.utils import doImportType
@@ -61,8 +62,6 @@ if TYPE_CHECKING:
     from lsst.daf.butler.registry.interfaces import DatasetIdRef, DatastoreRegistryBridgeManager
     from lsst.resources import ResourcePathExpression
 
-    from .fileDatastoreClient import FileDatastoreGetPayload
-
 log = getLogger(__name__)
 
 
@@ -411,7 +410,7 @@ class ChainedDatastore(Datastore):
 
         raise FileNotFoundError(f"Dataset {ref} could not be found in any of the datastores")
 
-    def prepare_get_for_external_client(self, ref: DatasetRef) -> FileDatastoreGetPayload | None:
+    def prepare_get_for_external_client(self, ref: DatasetRef) -> list[DatasetLocationInformation] | None:
         datastore = self._get_matching_datastore(ref)
         if datastore is None:
             return None

{lsst_daf_butler-29.2025.2900 → lsst_daf_butler-29.2025.3100}/python/lsst/daf/butler/datastores/fileDatastore.py

@@ -89,10 +89,6 @@ from lsst.daf.butler.datastores.file_datastore.retrieve_artifacts import (
     determine_destination_for_retrieved_artifact,
     unpack_zips,
 )
-from lsst.daf.butler.datastores.fileDatastoreClient import (
-    FileDatastoreGetPayload,
-    FileDatastoreGetPayloadFileInfo,
-)
 from lsst.daf.butler.registry.interfaces import (
     DatabaseInsertMode,
     DatastoreRegistryBridge,
@@ -110,7 +106,6 @@ from lsst.utils.logging import VERBOSE, getLogger
 from lsst.utils.timer import time_this
 
 from ..datastore import FileTransferMap, FileTransferRecord
-from ..datastore.stored_file_info import make_datastore_path_relative
 
 if TYPE_CHECKING:
     from lsst.daf.butler import DatasetProvenance, LookupKey
@@ -2304,27 +2299,14 @@ class FileDatastore(GenericBaseDatastore[StoredFileInfo]):
             allGetInfo, ref=ref, parameters=parameters, cache_manager=self.cacheManager
         )
 
-    def prepare_get_for_external_client(self, ref: DatasetRef) -> FileDatastoreGetPayload | None:
+    def prepare_get_for_external_client(self, ref: DatasetRef) -> list[DatasetLocationInformation] | None:
         # Docstring inherited
 
-        # 1 hour.  Chosen somewhat arbitrarily -- this is long enough that the
-        # client should have time to download a large file with retries if
-        # needed, but short enough that it will become obvious quickly that
-        # these URLs expire.
-        # From a strictly technical standpoint there is no reason this
-        # shouldn't be a day or more, but there seems to be a political issue
-        # where people think there is a risk of end users posting presigned
-        # URLs for people without access rights to download.
-        url_expiration_time_seconds = 1 * 60 * 60
-
         locations = self._get_dataset_locations_info(ref)
         if len(locations) == 0:
             return None
 
-        return FileDatastoreGetPayload(
-            datastore_type="file",
-            file_info=[_to_file_info_payload(info, url_expiration_time_seconds) for info in locations],
-        )
+        return locations
 
     @transactional
     def put(self, inMemoryDataset: Any, ref: DatasetRef, provenance: DatasetProvenance | None = None) -> None:
@@ -3229,17 +3211,3 @@ class FileDatastore(GenericBaseDatastore[StoredFileInfo]):
     def get_opaque_table_definitions(self) -> Mapping[str, DatastoreOpaqueTable]:
         # Docstring inherited from the base class.
         return {self._opaque_table_name: DatastoreOpaqueTable(self.makeTableSpec(), StoredFileInfo)}
-
-
-def _to_file_info_payload(
-    info: DatasetLocationInformation, url_expiration_time_seconds: int
-) -> FileDatastoreGetPayloadFileInfo:
-    location, file_info = info
-
-    datastoreRecords = file_info.to_simple()
-    datastoreRecords.path = make_datastore_path_relative(datastoreRecords.path)
-
-    return FileDatastoreGetPayloadFileInfo(
-        url=location.uri.generate_presigned_get_url(expiration_time_seconds=url_expiration_time_seconds),
-        datastoreRecords=datastoreRecords,
-    )

{lsst_daf_butler-29.2025.2900 → lsst_daf_butler-29.2025.3100}/python/lsst/daf/butler/remote_butler/__init__.py

@@ -25,6 +25,5 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-from ._factory import *
 from ._http_connection import ButlerServerError
 from ._remote_butler import *

{lsst_daf_butler-29.2025.2900 → lsst_daf_butler-29.2025.3100}/python/lsst/daf/butler/remote_butler/_config.py

@@ -25,16 +25,24 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+from __future__ import annotations
+
+from typing import Literal, TypeAlias
+
 from pydantic import AnyHttpUrl, BaseModel
 
 
+class RemoteButlerConfigModel(BaseModel):
+    """ButlerConfig properties for RemoteButler."""
+
+    remote_butler: RemoteButlerOptionsModel
+
+
 class RemoteButlerOptionsModel(BaseModel):
     """Model representing the remote server connection."""
 
     url: AnyHttpUrl
+    authentication: AuthenticationMode = "rubin_science_platform"
 
 
-class RemoteButlerConfigModel(BaseModel):
-    """Configuration representing a remote butler."""
-
-    remote_butler: RemoteButlerOptionsModel
+AuthenticationMode: TypeAlias = Literal["rubin_science_platform", "cadc"]

{lsst_daf_butler-29.2025.2900 → lsst_daf_butler-29.2025.3100}/python/lsst/daf/butler/remote_butler/_factory.py

@@ -36,10 +36,12 @@ from lsst.daf.butler.repo_relocation import replaceRoot
 from .._butler_config import ButlerConfig
 from .._butler_instance_options import ButlerInstanceOptions
 from ..registry import RegistryDefaults
-from ._authentication import get_authentication_token_from_environment
-from ._config import RemoteButlerConfigModel
+from ._config import RemoteButlerConfigModel, RemoteButlerOptionsModel
 from ._http_connection import RemoteButlerHttpConnection
 from ._remote_butler import RemoteButler, RemoteButlerCache
+from .authentication.cadc import CadcAuthenticationProvider
+from .authentication.interface import RemoteButlerAuthenticationProvider
+from .authentication.rubin import RubinAuthenticationProvider
 
 
 class RemoteButlerFactory:
@@ -49,9 +51,9 @@ class RemoteButlerFactory:
 
     Parameters
     ----------
-    server_url : `str`
-        The URL of the Butler server that RemoteButler instances created by
-        this factory will connect to.
+    config : `RemoteButlerOptionsModel`
+        `RemoteButler` configuration information (as read from `ButlerConfig`
+        YAML file).
     http_client : `httpx.Client`, optional
         The httpx connection pool that RemoteButler instances created by this
         factory will use for making HTTP requests.  If omitted, creates a new
@@ -60,11 +62,12 @@ class RemoteButlerFactory:
     Notes
     -----
     Most users should not directly call this constructor -- instead use
-    ``create_factory_from_config`` or ``create_factory_for_url``.
+    ``create_factory_from_config``.
     """
 
-    def __init__(self, server_url: str, http_client: httpx.Client | None = None):
-        self.server_url = server_url
+    def __init__(self, config: RemoteButlerOptionsModel, http_client: httpx.Client | None = None):
+        self._config = config
+        self.server_url = str(config.url)
         if http_client is not None:
             self.http_client = http_client
         else:
@@ -83,7 +86,9 @@ class RemoteButlerFactory:
         self._cache = RemoteButlerCache()
 
     @staticmethod
-    def create_factory_from_config(config: ButlerConfig) -> RemoteButlerFactory:
+    def create_factory_from_config(
+        config: ButlerConfig, http_client: httpx.Client | None = None
+    ) -> RemoteButlerFactory:
         # There is a convention in Butler config files where <butlerRoot> in a
         # configuration option refers to the directory containing the
         # configuration file. We allow this for the remote butler's URL so
@@ -93,42 +98,61 @@ class RemoteButlerFactory:
         if server_url_key in config:
             config[server_url_key] = replaceRoot(config[server_url_key], config.configDir)
         remote_config = RemoteButlerConfigModel.model_validate(config)
-        return RemoteButlerFactory.create_factory_for_url(str(remote_config.remote_butler.url))
+        return RemoteButlerFactory(remote_config.remote_butler, http_client=http_client)
 
     @staticmethod
-    def create_factory_for_url(server_url: str) -> RemoteButlerFactory:
-        return RemoteButlerFactory(server_url)
+    def create_factory_for_url(
+        server_url: str, http_client: httpx.Client | None = None
+    ) -> RemoteButlerFactory:
+        config = ButlerConfig(server_url)
+        return RemoteButlerFactory.create_factory_from_config(config, http_client=http_client)
 
-    def create_butler_for_access_token(
+    def _create_butler(
         self,
-        access_token: str,
         *,
-        butler_options: ButlerInstanceOptions | None = None,
-        use_disabled_datastore_cache: bool = True,
+        auth: RemoteButlerAuthenticationProvider,
+        butler_options: ButlerInstanceOptions | None,
+        enable_datastore_cache: bool = False,
     ) -> RemoteButler:
         if butler_options is None:
             butler_options = ButlerInstanceOptions()
         return RemoteButler(
             connection=RemoteButlerHttpConnection(
-                http_client=self.http_client, server_url=self.server_url, access_token=access_token
+                http_client=self.http_client, server_url=self.server_url, auth=auth
             ),
             defaults=RegistryDefaults.from_butler_instance_options(butler_options),
             cache=self._cache,
-            use_disabled_datastore_cache=use_disabled_datastore_cache,
+            use_disabled_datastore_cache=not enable_datastore_cache,
+        )
+
+    def create_butler_for_access_token(
+        self,
+        access_token: str,
+        *,
+        butler_options: ButlerInstanceOptions | None = None,
+        enable_datastore_cache: bool = False,
+    ) -> RemoteButler:
+        auth: RemoteButlerAuthenticationProvider
+        if self._config.authentication == "rubin_science_platform":
+            auth = RubinAuthenticationProvider(access_token)
+        elif self._config.authentication == "cadc":
+            auth = CadcAuthenticationProvider()
+        return self._create_butler(
+            auth=auth, butler_options=butler_options, enable_datastore_cache=enable_datastore_cache
         )
 
     def create_butler_with_credentials_from_environment(
         self,
         *,
         butler_options: ButlerInstanceOptions | None = None,
-        use_disabled_datastore_cache: bool = True,
+        enable_datastore_cache: bool = True,
     ) -> RemoteButler:
-        token = get_authentication_token_from_environment(self.server_url)
-        if token is None:
-            raise RuntimeError(
-                "Attempting to connect to Butler server,"
-                " but no access credentials were found in the environment."
-            )
-        return self.create_butler_for_access_token(
-            token, butler_options=butler_options, use_disabled_datastore_cache=use_disabled_datastore_cache
+        auth: RemoteButlerAuthenticationProvider
+        if self._config.authentication == "rubin_science_platform":
+            auth = RubinAuthenticationProvider.create_from_environment(self.server_url)
+        elif self._config.authentication == "cadc":
+            auth = CadcAuthenticationProvider()
+
+        return self._create_butler(
+            auth=auth, butler_options=butler_options, enable_datastore_cache=enable_datastore_cache
         )

lsst_daf_butler-29.2025.3100/python/lsst/daf/butler/remote_butler/_get.py

@@ -0,0 +1,98 @@
+from typing import Any
+
+from pydantic import AnyHttpUrl
+
+from lsst.resources import ResourcePath
+from lsst.resources.http import HttpResourcePath
+
+from .._dataset_ref import DatasetRef
+from .._location import Location
+from ..datastore.cache_manager import AbstractDatastoreCacheManager, DatastoreDisabledCacheManager
+from ..datastore.stored_file_info import StoredFileInfo
+from ..datastores.file_datastore.get import (
+    DatasetLocationInformation,
+    Mapping,
+    generate_datastore_get_information,
+    get_dataset_as_python_object_from_get_info,
+)
+from .authentication.interface import RemoteButlerAuthenticationProvider
+from .server_models import FileAuthenticationMode, FileInfoPayload, FileInfoRecord
+
+
+def get_dataset_as_python_object(
+    ref: DatasetRef,
+    payload: FileInfoPayload,
+    *,
+    auth: RemoteButlerAuthenticationProvider,
+    parameters: Mapping[str, Any] | None,
+    cache_manager: AbstractDatastoreCacheManager | None = None,
+) -> Any:
+    """Retrieve an artifact from storage and return it as a Python object.
+
+    Parameters
+    ----------
+    ref : `DatasetRef`
+        Metadata about this artifact.
+    payload : `FileInfoPayload`
+        Pre-processed information about each file associated with this
+        artifact.
+    auth : `RemoteButlerAuthenticationProvider`
+        Provides authentication headers for HTTP service hosting the artifact
+        files.
+    parameters : `Mapping`[`str`, `typing.Any`]
+        `StorageClass` and `Formatter` parameters to be used when converting
+        the artifact to a Python object.
+    cache_manager : `AbstractDatastoreCacheManager` or `None`, optional
+        Cache manager to use. If `None` the cache is disabled.
+
+    Returns
+    -------
+    python_object : `typing.Any`
+        The retrieved artifact, converted to a Python object.
+    """
+    fileLocations = [_to_dataset_location_information(file_info, auth) for file_info in payload.file_info]
+
+    datastore_file_info = generate_datastore_get_information(
+        fileLocations,
+        ref=ref,
+        parameters=parameters,
+    )
+    if cache_manager is None:
+        cache_manager = DatastoreDisabledCacheManager()
+    return get_dataset_as_python_object_from_get_info(
+        datastore_file_info, ref=ref, parameters=parameters, cache_manager=cache_manager
+    )
+
+
+def convert_http_url_to_resource_path(
+    url: AnyHttpUrl, auth: RemoteButlerAuthenticationProvider, auth_mode: FileAuthenticationMode
+) -> ResourcePath:
+    """Convert an HTTP URL to a ResourcePath instance with authentication
+    headers attached.
+
+    Parameters
+    ----------
+    url : `AnyHttpUrl`
+        URL to convert.
+    auth : `RemoteButlerAuthenticationProvider`
+        Provides authentication headers for the URL.
+    auth_mode : `FileAuthenticationMode`
+        Specifies which authentication headers to use.
+    """
+    if auth_mode == "none":
+        headers = None
+    elif auth_mode == "gafaelfawr":
+        headers = auth.get_server_headers()
+    elif auth_mode == "datastore":
+        headers = auth.get_datastore_headers()
+    else:
+        raise ValueError(f"Unknown authentication type: '{auth_mode}'")
+
+    return HttpResourcePath.create_http_resource_path(str(url), extra_headers=headers)
+
+
+def _to_dataset_location_information(
+    file_info: FileInfoRecord, auth: RemoteButlerAuthenticationProvider
+) -> DatasetLocationInformation:
+    path = convert_http_url_to_resource_path(file_info.url, auth, auth_mode=file_info.auth)
+    return (Location(None, path), StoredFileInfo.from_simple(file_info.datastoreRecords))

{lsst_daf_butler-29.2025.2900 → lsst_daf_butler-29.2025.3100}/python/lsst/daf/butler/remote_butler/_http_connection.py

@@ -42,13 +42,15 @@ from pydantic import BaseModel, ValidationError
 
 from lsst.daf.butler import __version__
 
-from ._authentication import get_authentication_headers
 from ._errors import deserialize_butler_user_error
+from .authentication.interface import RemoteButlerAuthenticationProvider
 from .server_models import CLIENT_REQUEST_ID_HEADER_NAME, ERROR_STATUS_CODE, ErrorResponseModel
 
 _AnyPydanticModel = TypeVar("_AnyPydanticModel", bound=BaseModel)
 """Generic type variable that accepts any Pydantic model class."""
 
+_USER_AGENT = f"RemoteButler/{__version__}"
+
 
 class RemoteButlerHttpConnection:
     """HTTP connection to a Butler server.
@@ -59,24 +61,16 @@ class RemoteButlerHttpConnection:
         HTTP connection pool we will use to connect to the server.
     server_url : `str`
         URL of the Butler server we will connect to.
-    access_token : `str`
-        Rubin Science Platform Gafaelfawr access token that will be used to
-        authenticate with the server.
+    auth : `RemoteButlerAuthenticationProvider`
+        Provides headers that will be used to authenticate with the server.
     """
 
-    def __init__(self, http_client: httpx.Client, server_url: str, access_token: str) -> None:
+    def __init__(
+        self, http_client: httpx.Client, server_url: str, auth: RemoteButlerAuthenticationProvider
+    ) -> None:
         self._client = http_client
         self.server_url = server_url
-        self._access_token = access_token
-
-        self._auth_headers = get_authentication_headers(access_token)
-        headers = {"user-agent": f"RemoteButler/{__version__}"}
-
-        self._headers = self._auth_headers | headers
-
-    @property
-    def authentication_headers(self) -> dict[str, str]:
-        return self._auth_headers
+        self.auth = auth
 
     def post(self, path: str, model: BaseModel) -> httpx.Response:
         """Send a POST request to the Butler server.
@@ -196,8 +190,8 @@ class RemoteButlerHttpConnection:
         url = self._get_url(path)
 
         request_id = str(uuid4())
-        request_headers = {CLIENT_REQUEST_ID_HEADER_NAME: request_id}
-        request_headers.update(self._headers)
+        request_headers = {CLIENT_REQUEST_ID_HEADER_NAME: request_id, "user-agent": _USER_AGENT}
+        request_headers.update(self.auth.get_server_headers())
         if headers is not None:
             request_headers.update(headers)
 

{lsst_daf_butler-29.2025.2900 → lsst_daf_butler-29.2025.3100}/python/lsst/daf/butler/remote_butler/_remote_butler.py

@@ -45,10 +45,6 @@ from lsst.daf.butler.datastores.file_datastore.retrieve_artifacts import (
     retrieve_and_zip,
     unpack_zips,
 )
-from lsst.daf.butler.datastores.fileDatastoreClient import (
-    FileDatastoreGetPayload,
-    get_dataset_as_python_object,
-)
 from lsst.resources import ResourcePath, ResourcePathExpression
 
 from .._butler import Butler, _DeprecatedDefault
@@ -70,6 +66,7 @@ from ..queries.tree import make_column_literal
 from ..registry import CollectionArgType, NoDefaultCollectionError, Registry, RegistryDefaults
 from ._collection_args import convert_collection_arg_to_glob_string_list
 from ._defaults import DefaultsHolder
+from ._get import convert_http_url_to_resource_path, get_dataset_as_python_object
 from ._http_connection import RemoteButlerHttpConnection, parse_model, quote_path_variable
 from ._query_driver import RemoteQueryDriver
 from ._query_results import convert_dataset_ref_results, read_query_results
@@ -79,6 +76,7 @@ from ._remote_butler_collections import RemoteButlerCollections
 from ._remote_file_transfer_source import RemoteFileTransferSource
 from .server_models import (
     CollectionList,
+    FileInfoPayload,
     FindDatasetRequestModel,
     FindDatasetResponseModel,
     GetDatasetTypeResponseModel,
@@ -303,6 +301,7 @@ class RemoteButler(Butler):  # numpydoc ignore=PR02
         return get_dataset_as_python_object(
             ref,
             _to_file_payload(model),
+            auth=self._connection.auth,
             parameters=parameters,
             cache_manager=self._cache_manager,
         )
@@ -355,7 +354,11 @@ class RemoteButler(Butler):  # numpydoc ignore=PR02
         response = self._get_file_info(datasetRefOrType, dataId, collections, None, kwargs)
         file_info = _to_file_payload(response).file_info
         if len(file_info) == 1:
-            return DatasetRefURIs(primaryURI=ResourcePath(str(file_info[0].url)))
+            return DatasetRefURIs(
+                primaryURI=convert_http_url_to_resource_path(
+                    file_info[0].url, self._connection.auth, file_info[0].auth
+                )
+            )
         else:
             components = {}
             for f in file_info:
@@ -365,7 +368,9 @@ class RemoteButler(Butler):  # numpydoc ignore=PR02
                         f"DatasetId {response.dataset_ref.id} has a component file"
                         " with no component name defined"
                     )
-                components[component] = ResourcePath(str(f.url))
+                components[component] = convert_http_url_to_resource_path(
+                    f.url, self._connection.auth, f.auth
+                )
             return DatasetRefURIs(componentURIs=components)
 
     def get_dataset_type(self, name: str) -> DatasetType:
@@ -734,7 +739,7 @@ class RemoteButler(Butler):  # numpydoc ignore=PR02
         return self._registry_defaults.get().dataId.to_simple(minimal=True).dataId
 
 
-def _to_file_payload(get_file_response: GetFileResponseModel) -> FileDatastoreGetPayload:
+def _to_file_payload(get_file_response: GetFileResponseModel) -> FileInfoPayload:
     if get_file_response.artifact is None:
         ref = get_file_response.dataset_ref
         raise DatasetNotFoundError(f"Dataset is known, but artifact is not available. (datasetId='{ref.id}')")

{lsst_daf_butler-29.2025.2900 → lsst_daf_butler-29.2025.3100}/python/lsst/daf/butler/remote_butler/_remote_file_transfer_source.py

@@ -37,6 +37,7 @@ from lsst.utils.iteration import chunk_iterable
 from .._location import Location
 from ..datastore import FileTransferMap, FileTransferRecord, FileTransferSource
 from ..datastore.stored_file_info import StoredFileInfo
+from ._get import convert_http_url_to_resource_path
 from ._http_connection import RemoteButlerHttpConnection, parse_model
 from .server_models import (
     FileTransferRecordModel,
@@ -78,15 +79,7 @@ class RemoteFileTransferSource(FileTransferSource):
         return {}
 
     def _deserialize_file_transfer_record(self, record: FileTransferRecordModel) -> FileTransferRecord:
-        # If the server tells us it is necessary, attach the Gafaelfawr
-        # authentication headers to the URL.
-        if record.auth == "none":
-            headers = None
-        elif record.auth == "gafaelfawr":
-            headers = self._connection.authentication_headers
-        else:
-            raise ValueError(f"Unknown authentication type {record.auth}")
-        resource_path = HttpResourcePath.create_http_resource_path(str(record.url), extra_headers=headers)
+        resource_path = convert_http_url_to_resource_path(record.url, self._connection.auth, record.auth)
         resource_path = _tweak_uri_for_unit_test(resource_path)
 
         return FileTransferRecord(
@@ -95,7 +88,7 @@ class RemoteFileTransferSource(FileTransferSource):
         )
 
 
-def _tweak_uri_for_unit_test(path: HttpResourcePath) -> HttpResourcePath:
+def _tweak_uri_for_unit_test(path: ResourcePath) -> ResourcePath:
     # Provide a place for unit tests to hook in and modify URLs, since there is
     # no actual HTTP server reachable via a domain name during testing.
     return path

lsst_daf_butler-29.2025.3100/python/lsst/daf/butler/remote_butler/authentication/cadc.py

@@ -0,0 +1,54 @@
+# This file is part of daf_butler.
+#
+# Developed for the LSST Data Management System.
+# This product includes software developed by the LSST Project
+# (http://www.lsst.org).
+# See the COPYRIGHT file at the top-level directory of this distribution
+# for details of code ownership.
+#
+# This software is dual licensed under the GNU General Public License and also
+# under a 3-clause BSD license. Recipients may choose which of these licenses
+# to use; please see the files gpl-3.0.txt and/or bsd_license.txt,
+# respectively.  If you choose the GPL option then the following text applies
+# (but note that there is still no warranty even if you opt for BSD instead):
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from __future__ import annotations
+
+from .interface import RemoteButlerAuthenticationProvider
+
+
+class CadcAuthenticationProvider(RemoteButlerAuthenticationProvider):
+    """Provide HTTP headers required for authenticating the user at the
+    Canadian Astronomy Data Centre.
+    """
+
+    # NOTE -- This object needs to be pickleable. It will sometimes be
+    # serialized and transferred to another process to execute file transfers.
+
+    def __init__(self) -> None:
+        # TODO: Load authentication information somehow
+        pass
+
+    def get_server_headers(self) -> dict[str, str]:
+        # TODO: I think you mentioned that you might not require
+        # authentication for the Butler server REST API initially --
+        # if so, you can leave this blank.
+        return {}
+
+    def get_datastore_headers(self) -> dict[str, str]:
+        # TODO: Supply the headers needed to access the Storage Inventory
+        # system.
+        return {"Authorization": "Bearer stub"}