sapiopycommons 2025.4.8a473__py3-none-any.whl → 2025.4.9a150__py3-none-any.whl

sapiopycommons/eln/experiment_report_util.py

@@ -4,16 +4,15 @@ from sapiopylib.rest.pojo.CustomReport import CustomReportCriteria, AbstractRepo
 from sapiopylib.rest.pojo.datatype.FieldDefinition import FieldType
 from sapiopylib.rest.pojo.eln.ElnExperiment import ElnExperiment, ElnExperimentQueryCriteria
 from sapiopylib.rest.pojo.eln.SapioELNEnums import ElnExperimentStatus, ElnBaseDataType
-from sapiopylib.rest.utils.recordmodel.PyRecordModel import PyRecordModel
 from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedType
 
-from sapiopycommons.customreport.auto_pagers import CustomReportDictAutoPager
 from sapiopycommons.customreport.custom_report_builder import CustomReportBuilder
 from sapiopycommons.customreport.term_builder import TermBuilder
 from sapiopycommons.datatype.pseudo_data_types import EnbEntryOptionsPseudoDef, NotebookExperimentOptionPseudoDef, \
     NotebookExperimentPseudoDef, ExperimentEntryRecordPseudoDef, EnbEntryPseudoDef
 from sapiopycommons.general.aliases import SapioRecord, UserIdentifier, AliasUtil, FieldValue, \
     ExperimentEntryIdentifier, ExperimentIdentifier
+from sapiopycommons.general.custom_report_util import CustomReportUtil
 from sapiopycommons.general.exceptions import SapioException
 from sapiopycommons.recordmodel.record_handler import RecordHandler
 
@@ -202,7 +201,7 @@ class ExperimentReportUtil:
         criteria = report_builder.build_report_criteria()
 
         ret_val: dict[SapioRecord, int] = {}
-        rows: list[dict[str, FieldValue]] = CustomReportDictAutoPager(context, criteria).get_all_at_once()
+        rows: list[dict[str, FieldValue]] = CustomReportUtil.run_custom_report(context, criteria)
         for row in rows:
             dt: str = row[EnbEntryPseudoDef.DATA_TYPE_NAME__FIELD_NAME.field_name]
             exp_id: int = row[EnbEntryPseudoDef.EXPERIMENT_ID__FIELD_NAME.field_name]
@@ -210,20 +209,16 @@ class ExperimentReportUtil:
                 ret_val[record] = exp_id
         return ret_val
 
-    # CR-47491: Support providing a data type name string to receive PyRecordModels instead of requiring a WrapperType.
     @staticmethod
     def map_experiments_to_records_of_type(context: UserIdentifier, exp_ids: list[ExperimentIdentifier],
-                                           wrapper_type: type[WrappedType] | str) \
-            -> dict[int, list[WrappedType] | list[PyRecordModel]]:
+                                           wrapper_type: type[WrappedType]) -> dict[int, list[WrappedType]]:
         """
         Return a dictionary mapping each experiment id to a list of records of the given type that were used in each
         experiment. If an experiment didn't use any records of the given type then it will be mapped to an empty list.
 
         :param context: The current webhook context or a user object to send requests from.
         :param exp_ids: A list of experiment identifiers.
-        :param wrapper_type: The record model wrapper or data type name to use, corresponds to which data type we will
-            query for. If a data type name is provided, the returned records will be PyRecordModels instead of
-            WrappedRecordModels.
+        :param wrapper_type: The record model wrapper to use, corresponds to which data type we will query for.
         :return: A dictionary mapping each experiment id to a list of records of the given type that were used in that
             experiment.
         """
@@ -232,7 +227,7 @@ class ExperimentReportUtil:
 
         user = AliasUtil.to_sapio_user(context)
         record_handler = RecordHandler(user)
-        data_type_name: str = AliasUtil.to_data_type_name(wrapper_type)
+        data_type_name: str = wrapper_type.get_wrapper_data_type_name()
 
         exp_ids: list[int] = AliasUtil.to_notebook_ids(exp_ids)
         rows = ExperimentReportUtil.__get_record_experiment_relation_rows(user, data_type_name, exp_ids=exp_ids)
@@ -273,7 +268,7 @@ class ExperimentReportUtil:
 
         # Ensure that each experiment appears in the dictionary, even if it has no experiment options.
         options: dict[int, dict[str, str]] = {x: {} for x in exp_ids}
-        results: list[dict[str, FieldValue]] = CustomReportDictAutoPager(context, report).get_all_at_once()
+        results: list[dict[str, FieldValue]] = CustomReportUtil.run_custom_report(context, report)
         for row in results:
             exp_id: int = row[NotebookExperimentOptionPseudoDef.EXPERIMENT_ID__FIELD_NAME.field_name]
             key: str = row[NotebookExperimentOptionPseudoDef.OPTION_KEY__FIELD_NAME.field_name]
@@ -304,7 +299,7 @@ class ExperimentReportUtil:
 
         # Ensure that each entry appears in the dictionary, even if it has no entry options.
         options: dict[int, dict[str, str]] = {x: {} for x in entries}
-        results: list[dict[str, FieldValue]] = CustomReportDictAutoPager(context, report).get_all_at_once()
+        results: list[dict[str, FieldValue]] = CustomReportUtil.run_custom_report(context, report)
         for row in results:
             entry_id: int = row[EnbEntryOptionsPseudoDef.ENTRY_ID__FIELD_NAME.field_name]
             key: str = row[EnbEntryOptionsPseudoDef.ENTRY_OPTION_KEY__FIELD_NAME.field_name]
@@ -337,7 +332,7 @@ class ExperimentReportUtil:
         report = report_builder.build_report_criteria()
 
         ret_val: dict[int, str] = {}
-        results: list[dict[str, FieldValue]] = CustomReportDictAutoPager(context, report).get_all_at_once()
+        results: list[dict[str, FieldValue]] = CustomReportUtil.run_custom_report(context, report)
         for row in results:
             exp_id: int = row[NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME.field_name]
             name: str = row["TemplateExperimentName"]
@@ -586,7 +581,7 @@ class ExperimentReportUtil:
         """
         user = AliasUtil.to_sapio_user(context)
         exp_ids: list[int] = []
-        for row in CustomReportDictAutoPager(user, report):
+        for row in CustomReportUtil.run_custom_report(user, report):
             exp_ids.append(row[NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME.field_name])
         if not exp_ids:
             return []
@@ -651,4 +646,4 @@ class ExperimentReportUtil:
         report_builder.add_join(records_entry_join, ExperimentEntryRecordPseudoDef.DATA_TYPE_NAME)
         report_builder.add_join(experiment_entry_enb_entry_join, EnbEntryPseudoDef.DATA_TYPE_NAME)
         report_builder.add_join(enb_entry_experiment_join, NotebookExperimentPseudoDef.DATA_TYPE_NAME)
-        return CustomReportDictAutoPager(user, report_builder.build_report_criteria()).get_all_at_once()
+        return CustomReportUtil.run_custom_report(user, report_builder.build_report_criteria())

sapiopycommons/eln/plate_designer.py

@@ -1,64 +1,43 @@
 from sapiopylib.rest.utils.Protocols import ElnEntryStep
-from sapiopylib.rest.utils.plates.PlatingUtils import PlateLocation
-from sapiopylib.rest.utils.recordmodel.PyRecordModel import PyRecordModel
 from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedType
 
-from sapiopycommons.datatype.data_fields import PlateDesignerWellElementFields
 from sapiopycommons.eln.experiment_handler import ExperimentHandler
-from sapiopycommons.eln.experiment_tags import PLATE_IDS_TAG
-from sapiopycommons.general.aliases import RecordIdentifier, AliasUtil, RecordModel, FieldValue
+from sapiopycommons.general.aliases import SapioRecord, RecordIdentifier, AliasUtil
 from sapiopycommons.general.exceptions import SapioException
 from sapiopycommons.recordmodel.record_handler import RecordHandler
 
-# Shorthands for longer type names.
-WellElement = PlateDesignerWellElementFields
+PLATE_IDS_TAG: str = "MultiLayerPlating_Plate_RecordIdList"
 
 
-# FR-47486: Change the PlateDesignerEntry class to extend ElnEntryStep instead of containing one.
-class PlateDesignerEntry(ElnEntryStep):
+class PlateDesignerEntry:
     """
     A wrapper for 3D plate designer entries in experiments, providing functions for common actions when dealing with
     such entries.
     """
-    _exp_handler: ExperimentHandler
-    _rec_handler: RecordHandler
-    _plates: list[RecordModel] | None
-    _aliquots: list[RecordModel] | None
-    _sources: list[RecordModel] | None
-    _designer_elements: list[RecordModel] | None
-    _designer_elements_by_plate: dict[int, list[RecordModel]] | None
-    _plate_ids: list[int] | None
+    step: ElnEntryStep
+    __exp_handler: ExperimentHandler
+    __rec_handler: RecordHandler
+    __plates: list[SapioRecord] | None
+    __aliquots: list[SapioRecord] | None
+    __sources: list[SapioRecord] | None
+    __designer_elements: list[SapioRecord] | None
+    __plate_ids: list[int] | None
 
     def __init__(self, step: ElnEntryStep, exp_handler: ExperimentHandler):
         """
         :param step: The ElnEntryStep that is the 3D plate designer entry.
         :param exp_handler: An ExperimentHandler for the experiment that this entry comes from.
         """
-        super().__init__(exp_handler.protocol, step.eln_entry)
-        self._exp_handler = exp_handler
-        self._rec_handler = RecordHandler(exp_handler.user)
-        self._plates = None
-        self._aliquots = None
-        self._sources = None
-        self._designer_elements = None
-        self._designer_elements_by_plate = None
-        self._plate_ids = None
-
-    @property
-    def step(self) -> ElnEntryStep:
-        return self
-
-    def clear_cache(self) -> None:
-        """
-        Clear the caches for the plates and plate designer well elements in this plate designer entry. This will require
-        a new webservice call to get the plates and designer elements the next time they are requested.
-        """
-        self._plates = None
-        self._designer_elements = None
-        self._designer_elements_by_plate = None
+        self.step = step
+        self.__exp_handler = exp_handler
+        self.__rec_handler = RecordHandler(exp_handler.context)
+        self.__plates = None
+        self.__aliquots = None
+        self.__sources = None
+        self.__designer_elements = None
+        self.__plate_ids = None
 
-    # CR-47491: Support not providing a wrapper type to receive PyRecordModels instead of WrappedRecordModels.
-    def get_plates(self, wrapper_type: type[WrappedType] | None = None) -> list[WrappedType] | list[PyRecordModel]:
+    def get_plates(self, wrapper_type: type[WrappedType]) -> list[WrappedType]:
         """
         Get the plates that are in the designer entry.
 
@@ -66,16 +45,13 @@ class PlateDesignerEntry(ElnEntryStep):
         will be invalidated if a set_plates or add_plates call is made, requiring a new webservice call the next time
         this function is called.
 
-        :param wrapper_type: The record model wrapper to use on the plates. If not provided, the returned records will
-            be PyRecordModels instead of WrappedRecordModels.
+        :param wrapper_type: The record model wrapper to use.
         :return: A list of the plates in the designer entry.
         """
-        if self._plates is not None:
-            return self._plates
-        if wrapper_type is None:
-            wrapper_type = "Plate"
-        self._plates = self._rec_handler.query_models_by_id(wrapper_type, self.__get_plate_ids())
-        return self._plates
+        if self.__plates is not None:
+            return self.__plates
+        self.__plates = self.__rec_handler.query_models_by_id(wrapper_type, self.__get_plate_ids())
+        return self.__plates
 
     def set_plates(self, plates: list[RecordIdentifier]) -> None:
         """
@@ -100,50 +76,47 @@ class PlateDesignerEntry(ElnEntryStep):
         record_ids: list[int] = AliasUtil.to_record_ids(plates)
         self.__set_plate_ids(self.__get_plate_ids() + record_ids)
 
-    def get_sources(self, wrapper_type: type[WrappedType] | str) -> list[WrappedType] | list[PyRecordModel]:
+    def get_sources(self, wrapper_type: type[WrappedType]) -> list[WrappedType]:
         """
         Get the source records that were used to populate the plate designer entry's sample table. This looks for the
-        entries that the plate designer entry is implicitly dependent upon and gets their records if they match the
-        data type name of the given wrapper.
+        entries that the plate designer entry is dependent upon and gets their records if they match the data type name
+        of the given wrapper.
 
         Makes a webservice call to retrieve the dependent entries if the experiment handler had not already cached it.
         Makes another webservice call to get the records from the dependent entry and caches them for future calls.
 
-        :param wrapper_type: The record model wrapper or data type name of the records to retrieve. If a data type name
-            is provided, then the returned records will be PyRecordModels instead of WrappedRecordModels.
+        :param wrapper_type: The record model wrapper to use.
         :return: A list of the source records that populate the plate designer entry's sample table.
         """
-        if self._sources is not None:
-            return self._sources
+        if self.__sources is not None:
+            return self.__sources
 
         records: list[WrappedType] = []
-        dependent_ids: list[int] = self.step.eln_entry.related_entry_id_set
-        for step in self._exp_handler.get_all_steps(wrapper_type):
+        dependent_ids: list[int] = self.step.eln_entry.dependency_set
+        for step in self.__exp_handler.get_all_steps(wrapper_type):
             if step.get_id() in dependent_ids:
-                records.extend(self._exp_handler.get_step_models(step, wrapper_type))
+                records.extend(self.__exp_handler.get_step_models(step, wrapper_type))
 
-        self._sources = records
-        return self._sources
+        self.__sources = records
+        return self.__sources
 
-    def get_aliquots(self, wrapper_type: type[WrappedType] | None = None) -> list[WrappedType] | list[PyRecordModel]:
+    def get_aliquots(self, wrapper_type: type[WrappedType]) -> list[WrappedType]:
         """
         Get the aliquots that were created from this plate designer entry upon its submission.
 
         Makes a webservice call to retrieve the aliquots from the plate designer entry and caches them for future calls.
 
-        :param wrapper_type: The record model wrapper to use. If not provided, the returned records will be
-            PyRecordModels instead of WrappedRecordModels.
+        :param wrapper_type: The record model wrapper to use.
         :return: A list of the aliquots created by the plate designer entry.
         """
-        if not self._exp_handler.step_is_submitted(self.step):
+        if not self.__exp_handler.step_is_submitted(self.step):
             raise SapioException("The plate designer entry must be submitted before its aliquots can be retrieved.")
-        if self._aliquots is not None:
-            return self._aliquots
-        self._aliquots = self._exp_handler.get_step_models(self.step, wrapper_type)
-        return self._aliquots
+        if self.__aliquots is not None:
+            return self.__aliquots
+        self.__aliquots = self.__exp_handler.get_step_models(self.step, wrapper_type)
+        return self.__aliquots
 
-    def get_plate_designer_well_elements(self, wrapper_type: type[WrappedType] | None = None) \
-            -> list[WrappedType] | list[PyRecordModel]:
+    def get_plate_designer_well_elements(self, wrapper_type: type[WrappedType]) -> list[WrappedType]:
         """
         Get the plate designer well elements for the plates in the plate designer entry. These are the records in the
         system that determine how wells are displayed on each plate in the entry.
@@ -152,101 +125,28 @@ class PlateDesignerEntry(ElnEntryStep):
         This cache will be invalidated if a set_plates or add_plates call is made, requiring a new webservice call the
         next time this function is called.
 
-        :param wrapper_type: The record model wrapper to use. If not provided, the returned records will be
-            PyRecordModels instead of WrappedRecordModels.
-        :return: A list of the plate designer well elements in the designer entry.
-        """
-        if self._designer_elements is not None:
-            return self._designer_elements
-        if wrapper_type is None:
-            wrapper_type: str = WellElement.DATA_TYPE_NAME
-        self._designer_elements = self._rec_handler.query_models(wrapper_type,
-                                                                 WellElement.PLATE_RECORD_ID__FIELD,
-                                                                 self.__get_plate_ids())
-        if self._designer_elements_by_plate is None:
-            self._designer_elements_by_plate = {}
-        self._designer_elements_by_plate.clear()
-        for element in self._designer_elements:
-            plate_id: int = element.get(WellElement.PLATE_RECORD_ID__FIELD)
-            self._designer_elements_by_plate.setdefault(plate_id, []).append(element)
-        return self._designer_elements
-
-    def get_well_elements_by_plate(self, plate: RecordIdentifier, wrapper_type: type[WrappedType] | None = None) \
-            -> list[WrappedType] | list[PyRecordModel]:
-        """
-        Get the plate designer well elements for the given plate in the plate designer entry. These are the records in
-        the system that determine how wells are displayed on the plate in the entry.
-
-        Makes a webservice call to get the plate designer well elements of the entry and caches them for future calls.
-        This cache will be invalidated if a set_plates or add_plates call is made, requiring a new webservice call the
-        next time this function is called.
-
-        :param plate: The plate to get the well elements for.
-        :param wrapper_type: The record model wrapper to use. If not provided, the returned records will be
-            PyRecordModels instead of WrappedRecordModels.
+        :param wrapper_type: The record model wrapper to use.
         :return: A list of the plate designer well elements in the designer entry.
         """
-        plate: int = AliasUtil.to_record_id(plate)
-        if plate not in self.__get_plate_ids():
-            raise SapioException(f"Plate record ID {plate} is not in this plate designer entry.")
-        if self._designer_elements_by_plate is None:
-            self.get_plate_designer_well_elements(wrapper_type)
-        return self._designer_elements_by_plate[plate]
-
-    def create_well_element(self, sample: RecordModel, plate: RecordModel, location: PlateLocation | None = None,
-                            wrapper_type: type[WrappedType] | None = None) -> WrappedType | PyRecordModel:
-        """
-        Create a new plate designer well element for the input sample and plate. A record model manager store and commit
-        must be called to save this new well element to the server.
-
-        :param sample: The sample that the element is for. Must exist in the system (i.e. have a >0 record ID).
-        :param plate: The plate that the element is for. Must exist in the system (i.e. have a >0 record ID).
-        :param location: The location of the well element. If not provided, the row and column position fields of the
-            sample will be used.
-        :param wrapper_type: The record model wrapper to use for the plate designer well element. If not provided, the
-            returned record will be a PyRecordModel instead of a WrappedRecordModel.
-        :return: The newly created PlateDesignerWellElementModel.
-        """
-        # Confirm that we can actually make a designer element for the input records.
-        if AliasUtil.to_record_id(sample) <= 0:
-            raise SapioException("Cannot create plate designer well element for sample without a record ID.")
-        if AliasUtil.to_record_id(plate) <= 0:
-            raise SapioException("Cannot create plate designer well element for plate without a record ID.")
-        if AliasUtil.to_data_type_name(sample) != "Sample":
-            raise SapioException("Sample record must be of type Sample.")
-        if AliasUtil.to_data_type_name(plate) != "Plate":
-            raise SapioException("Plate record must be of type Plate.")
-
-        dt: type[WrappedType] | str = wrapper_type if wrapper_type else WellElement.DATA_TYPE_NAME
-        plate_id: int = AliasUtil.to_record_id(plate)
-        fields: dict[str, FieldValue] = {
-            WellElement.SOURCE_RECORD_ID__FIELD: AliasUtil.to_record_id(sample),
-            WellElement.PLATE_RECORD_ID__FIELD: plate_id,
-            WellElement.ROW_POSITION__FIELD: location.row_pos if location else sample.get_field_value("RowPosition"),
-            WellElement.COL_POSITION__FIELD: str(location.col_pos) if location else sample.get_field_value("ColPosition"),
-            WellElement.SOURCE_DATA_TYPE_NAME__FIELD: "Sample",
-        }
-        element = self._rec_handler.add_models_with_data(dt, [fields])[0]
-
-        # Add the new element to the cache.
-        if self._designer_elements is not None:
-            self._designer_elements.append(element)
-        if self._designer_elements_by_plate is not None and plate_id in self._designer_elements_by_plate:
-            self._designer_elements_by_plate.setdefault(plate_id, []).append(element)
-        return element
+        if self.__designer_elements is not None:
+            return self.__designer_elements
+        self.__designer_elements = self.__rec_handler.query_models(wrapper_type, "PlateRecordId",
+                                                                   self.__get_plate_ids())
+        return self.__designer_elements
 
     def __get_plate_ids(self) -> list[int]:
-        if self._plate_ids is not None:
-            return self._plate_ids
-        id_tag: str = self._exp_handler.get_step_option(self.step, PLATE_IDS_TAG)
+        if self.__plate_ids is not None:
+            return self.__plate_ids
+        id_tag: str = self.__exp_handler.get_step_option(self.step, PLATE_IDS_TAG)
         if not id_tag:
             raise SapioException("No plates in the plate designer entry")
-        self._plate_ids = [int(x) for x in id_tag.split(",")]
-        return self._plate_ids
+        self.__plate_ids = [int(x) for x in id_tag.split(",")]
+        return self.__plate_ids
 
     def __set_plate_ids(self, record_ids: list[int]) -> None:
         record_ids.sort()
-        self._exp_handler.add_step_options(self.step, {PLATE_IDS_TAG: ",".join([str(x) for x in record_ids])})
-        self._plate_ids = record_ids
+        self.__exp_handler.add_step_options(self.step, {PLATE_IDS_TAG: ",".join([str(x) for x in record_ids])})
+        self.__plate_ids = record_ids
         # The plates and designer elements caches have been invalidated.
-        self.clear_cache()
+        self.__plates = None
+        self.__designer_elements = None

sapiopycommons/files/file_bridge.py

@@ -1,7 +1,6 @@
 import base64
 import io
 import urllib.parse
-from typing import Any
 
 from requests import Response
 from sapiopylib.rest.User import SapioUser
@@ -9,36 +8,6 @@ from sapiopylib.rest.User import SapioUser
 from sapiopycommons.general.aliases import UserIdentifier, AliasUtil
 
 
-# FR-47387: Add support for the metadata endpoints in FileBridge.
-class FileBridgeMetadata:
-    """
-    Metadata for a file or directory in FileBridge.
-    """
-    file_name: str
-    """The name of the file or directory."""
-    is_file: bool
-    """True if the metadata is for a file, False if it is for a directory."""
-    is_directory: bool
-    """True if the metadata is for a directory, False if it is for a file."""
-    size: int
-    """The size of the file in bytes. For directories, this value will always be zero."""
-    creation_time: int
-    """The time the file or directory was created, in milliseconds since the epoch."""
-    last_accessed_time: int
-    """The time the file or directory was last accessed, in milliseconds since the epoch."""
-    last_modified_time: int
-    """The time the file or directory was last modified, in milliseconds since the epoch."""
-
-    def __init__(self, json_dict: dict[str, Any]):
-        self.file_name = json_dict['fileName']
-        self.is_file = json_dict['isFile']
-        self.is_directory = json_dict['isDirectory']
-        self.size = json_dict['size']
-        self.creation_time = json_dict['creationTime']
-        self.last_accessed_time = json_dict['lastAccessTime']
-        self.last_modified_time = json_dict['lastModifiedTime']
-
-
 # FR-46064 - Initial port of PyWebhookUtils to sapiopycommons.
 class FileBridge:
     @staticmethod
@@ -168,48 +137,3 @@ class FileBridge:
         user: SapioUser = AliasUtil.to_sapio_user(context)
         response = user.delete(sub_path, params=params)
         user.raise_for_status(response)
-
-    @staticmethod
-    def file_metadata(context: UserIdentifier, bridge_name: str, file_path: str) -> FileBridgeMetadata:
-        """
-        Get metadata for a file or directory in FileBridge.
-
-        The file path may be to a directory, in which case only the metadata for that directory will be returned. If you
-        want the metadata for the contents of a directory, then use the directory_metadata function.
-
-        :param context: The current webhook context or a user object to send requests from.
-        :param bridge_name: The name of the bridge to use. This is the "connection name" in the
-            file bridge configurations.
-        :param file_path: The path to the file to retrieve the metadata from.
-        :return: The metadata for the file.
-        """
-        sub_path = '/ext/filebridge/file/metadata'
-        params = {
-            'Filepath': f"bridge://{bridge_name}/{file_path}"
-        }
-        user: SapioUser = AliasUtil.to_sapio_user(context)
-        response = user.get(sub_path, params=params)
-        user.raise_for_status(response)
-        response_body: dict[str, Any] = response.json()
-        return FileBridgeMetadata(response_body)
-
-    @staticmethod
-    def directory_metadata(context: UserIdentifier, bridge_name: str, file_path: str) -> list[FileBridgeMetadata]:
-        """
-        Get metadata for every file or nested directory in a directory in FileBridge.
-
-        :param context: The current webhook context or a user object to send requests from.
-        :param bridge_name: The name of the bridge to use. This is the "connection name" in the
-            file bridge configurations.
-        :param file_path: The path to the directory to retrieve the metadata of the contents.
-        :return: A list of the metadata for the contents of the directory.
-        """
-        sub_path = '/ext/filebridge/directory/metadata'
-        params = {
-            'Filepath': f"bridge://{bridge_name}/{file_path}"
-        }
-        user: SapioUser = AliasUtil.to_sapio_user(context)
-        response = user.get(sub_path, params=params)
-        user.raise_for_status(response)
-        response_body: list[dict[str, Any]] = response.json()
-        return [FileBridgeMetadata(x) for x in response_body]