sapiopycommons 2025.4.9a150__py3-none-any.whl → 2025.4.9a476__py3-none-any.whl

sapiopycommons/eln/plate_designer.py

@@ -1,43 +1,64 @@
 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.general.aliases import SapioRecord, RecordIdentifier, AliasUtil
+from sapiopycommons.eln.experiment_tags import PLATE_IDS_TAG
+from sapiopycommons.general.aliases import RecordIdentifier, AliasUtil, RecordModel, FieldValue
 from sapiopycommons.general.exceptions import SapioException
 from sapiopycommons.recordmodel.record_handler import RecordHandler
 
-PLATE_IDS_TAG: str = "MultiLayerPlating_Plate_RecordIdList"
+# Shorthands for longer type names.
+WellElement = PlateDesignerWellElementFields
 
 
-class PlateDesignerEntry:
+# FR-47486: Change the PlateDesignerEntry class to extend ElnEntryStep instead of containing one.
+class PlateDesignerEntry(ElnEntryStep):
     """
     A wrapper for 3D plate designer entries in experiments, providing functions for common actions when dealing with
     such entries.
     """
-    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
+    _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
 
     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.
         """
-        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
+        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
 
-    def get_plates(self, wrapper_type: type[WrappedType]) -> list[WrappedType]:
+    # 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]:
         """
         Get the plates that are in the designer entry.
 
@@ -45,13 +66,16 @@ class PlateDesignerEntry:
         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.
+        :param wrapper_type: The record model wrapper to use on the plates. If not provided, the returned records will
+            be PyRecordModels instead of WrappedRecordModels.
         :return: A list of the plates in the designer entry.
         """
-        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
+        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
 
     def set_plates(self, plates: list[RecordIdentifier]) -> None:
         """
@@ -76,47 +100,50 @@ class PlateDesignerEntry:
         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]) -> list[WrappedType]:
+    def get_sources(self, wrapper_type: type[WrappedType] | str) -> list[WrappedType] | list[PyRecordModel]:
         """
         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 dependent upon and gets their records if they match the data type name
-        of the given wrapper.
+        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.
 
         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 to use.
+        :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.
         :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.dependency_set
-        for step in self.__exp_handler.get_all_steps(wrapper_type):
+        dependent_ids: list[int] = self.step.eln_entry.related_entry_id_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]) -> list[WrappedType]:
+    def get_aliquots(self, wrapper_type: type[WrappedType] | None = None) -> list[WrappedType] | list[PyRecordModel]:
         """
         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.
+        :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 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]) -> list[WrappedType]:
+    def get_plate_designer_well_elements(self, wrapper_type: type[WrappedType] | None = None) \
+            -> list[WrappedType] | list[PyRecordModel]:
         """
         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.
@@ -125,28 +152,101 @@ class PlateDesignerEntry:
         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.
+        :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.
         :return: A list of the plate designer well elements in the designer entry.
         """
-        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
+        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
 
     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.__plates = None
-        self.__designer_elements = None
+        self.clear_cache()

sapiopycommons/eln/step_creation.py

@@ -0,0 +1,235 @@
+from typing import Iterable
+
+from sapiopycommons.general.aliases import DataTypeIdentifier, FieldIdentifier, ExperimentEntryIdentifier
+from sapiopylib.rest.pojo.TableColumn import TableColumn
+from sapiopylib.rest.pojo.datatype.FieldDefinition import AbstractVeloxFieldDefinition
+from sapiopylib.rest.pojo.eln.SapioELNEnums import ExperimentEntryStatus, ElnEntryType
+from sapiopylib.rest.pojo.eln.field_set import ElnFieldSetInfo
+
+
+# CR-47564: Created these classes to streamline entry creation using the ExperimentEntryFactory.
+class StepCreation:
+    """
+    An object that contains the criteria for creating a new entry in the experiment.
+    """
+    _entry_type: ElnEntryType
+    """The type of the entry to be created."""
+    is_shown_in_template: bool | None
+    """Whether the entry will appear in the template if the experiment this entry is in is saved to a new template."""
+    is_removable: bool | None
+    """Whether the entry can be removed by users."""
+    is_renamable: bool | None
+    """Whether the entry can be renamed by users."""
+    is_static_view: bool | None
+    """Whether the entry's attachment is static. For attachment entries only. Static attachment entries will store
+    their attachment data in the template."""
+    related_entry_set: Iterable[ExperimentEntryIdentifier | str] | None
+    """The IDs of the entries this entry is implicitly dependent on. If any of the entries are deleted then this entry
+    is also deleted."""
+    dependency_set: Iterable[ExperimentEntryIdentifier | str] | None
+    """The IDs of the entries this entry is dependent on. Requires the entries to be completed before this entry will
+    be enabled."""
+    requires_grabber_plugin: bool
+    """Whether to run a grabber plugin when this entry is initialized."""
+    entry_singleton_id: str | None
+    """When this field is present (i.e. not null or blank) it will enforce that only one entry with this singleton
+    value is present in the experiment. If you attempt to create an entry with the singletonId of an entry already
+    present in the experiment it will return the existing entry instead of creating a new one. If an entry isn't
+    present in the Notebook Experiment with a matching singletonId it will create a new entry like normal."""
+    is_hidden: bool | None
+    """Whether the user is able to visibly see this entry within the experiment."""
+    entry_height: int | None
+    """The height of this entry in pixels. Setting the height to 0 will cause the entry to auto-size to its contents."""
+    description: str | None
+    """The description of the entry."""
+    is_initialization_required: bool | None
+    """Whether the user must manually initialize this entry by clicking on it."""
+    collapse_entry: bool | None
+    """Whether the entry should be collapsed by default."""
+    entry_status: ExperimentEntryStatus | None
+    """The current status of the entry."""
+    template_item_fulfilled_timestamp: int | None
+    """The time in milliseconds since the epoch that this entry became initialized."""
+    entry_options: dict[str, str] | None
+    """The entry options of the entry."""
+
+    def __init__(self, entry_type: ElnEntryType):
+        self._entry_type = entry_type
+        self.is_shown_in_template = None
+        self.is_removable = None
+        self.is_renamable = None
+        self.is_static_view = None
+        self._related_entry_set = None
+        self._dependency_set = None
+        self.requires_grabber_plugin = False
+        self.entry_singleton_id = None
+        self.is_hidden = None
+        self.entry_height = None
+        self.description = None
+        self.is_initialization_required = None
+        self.collapse_entry = None
+        self.entry_status = None
+        self.template_item_fulfilled_timestamp = None
+        self.entry_options = None
+
+    @property
+    def entry_type(self) -> ElnEntryType:
+        return self._entry_type
+
+class AttachmentStepCreation(StepCreation):
+    """
+    An object that contains criteria for creating a new attachment entry in an experiment.
+    """
+    def __init__(self):
+        super().__init__(ElnEntryType.Attachment)
+
+
+class DashboardStepCreation(StepCreation):
+    """
+    An object that contains criteria for creating a new dashboard entry in an experiment.
+    """
+    source_entry: ExperimentEntryIdentifier | str | None
+    """The entry that contains the source data for this entry's dashboard(s)."""
+    dashboard_guids: Iterable[str] | None
+    """The GUIDs of the dashboards to display in this entry."""
+
+    def __init__(self):
+        super().__init__(ElnEntryType.Dashboard)
+        self.source_entry = None
+        self.dashboard_guids = None
+
+
+class GlobalDtFormStepCreation(StepCreation):
+    """
+    An object that contains criteria for creating a new global data type form entry in an experiment.
+    """
+    layout_name: str | None
+    """The name of the data type layout to be displayed in this form. The layout must be for the data type for this
+    entry."""
+    form_names: Iterable[str] | None
+    """The names of the components in the chosen data type layout to display in this form."""
+    extension_types: Iterable[DataTypeIdentifier] | None
+    """The names of the extension data types to display fields from within the form."""
+    field_names: Iterable[FieldIdentifier] | None
+    """A list of data field names for the fields to be displayed in the form."""
+
+    def __init__(self):
+        super().__init__(ElnEntryType.Form)
+        self.form_names = None
+        self.layout_name = None
+        self.extension_types = None
+        self.field_names = None
+
+
+class ELnDtFormStepCreation(StepCreation):
+    """
+    An object that contains criteria for creating a new ELN data type form entry in an experiment.
+    """
+    is_field_addable: bool | None
+    """Whether new fields can be added to the entry by users."""
+    is_existing_field_removable: bool | None
+    """Whether existing fields on the entry can be removed by users."""
+    field_sets: Iterable[int | str | ElnFieldSetInfo] | None
+    """The predefined field sets to display in this form."""
+    field_definitions: Iterable[AbstractVeloxFieldDefinition] | None
+    """New field definitions to be created for this entry."""
+    predefined_field_names: Iterable[str] | None
+    """The names of the predefined fields to display in this form."""
+
+    def __init__(self):
+        super().__init__(ElnEntryType.Form)
+        self.is_field_addable = None
+        self.is_existing_field_removable = None
+        self.field_sets = None
+        self.field_definitions = None
+        self.predefined_field_names = None
+        self.table_columns = None
+
+
+class PluginStepCreation(StepCreation):
+    """
+    An object that contains criteria for creating a new plugin entry in an experiment.
+    """
+    plugin_name: str | None
+    """The client side plugin name to render this entry with."""
+    using_template_data: bool | None
+    """Whether this entry will use the data from the template."""
+    provides_template_data: bool | None
+    """Whether this entry can provide data to copy into a new template."""
+
+    def __init__(self):
+        super().__init__(ElnEntryType.Plugin)
+        self.plugin_name = None
+        self.using_template_data = None
+        self.provides_template_data = None
+
+
+class GlobalDtTableStepCreation(StepCreation):
+    """
+    An object that contains criteria for creating a new global data type table entry in an experiment.
+    """
+    layout_name: str | None
+    """The name of the data type layout to display in this table."""
+    extension_types: Iterable[str] | None
+    """The names of the extension data types to display fields from within the table."""
+    table_columns: Iterable[TableColumn] | None
+    """The columns to display in the table. This can be used to change the sort order and direction of columns."""
+    field_names: Iterable[FieldIdentifier] | None
+    """A list of data field names for the fields to be displayed in the table. These will be added as TableColumns and
+    placed after any of the existing columns specified in the table_columns parameter without any sorting."""
+    show_key_fields: bool | None
+    """Whether the key fields of the data type should be shown in the entry."""
+
+    def __init__(self):
+        super().__init__(ElnEntryType.Table)
+        self.layout_name = None
+        self.extension_types = None
+        self.table_columns = None
+        self.show_key_fields = None
+
+
+class ELnDtTableStepCreation(StepCreation):
+    """
+    An object that contains criteria for creating a new ELN data type table entry in an experiment.
+    """
+    is_field_addable: bool | None
+    """Whether new fields can be added to the entry by users."""
+    is_existing_field_removable: bool | None
+    """Whether existing fields on the entry can be removed by users."""
+    field_sets: Iterable[int | str | ElnFieldSetInfo] | None
+    """The predefined field sets to display in this form."""
+    field_definitions: Iterable[AbstractVeloxFieldDefinition] | None
+    """New field definitions to be created for this entry."""
+    predefined_field_names: Iterable[str] | None
+    """The names of the predefined fields to display in this form."""
+    table_columns: Iterable[TableColumn] | None
+    """The columns to display in the table."""
+
+    def __init__(self):
+        super().__init__(ElnEntryType.Table)
+        self.is_field_addable = None
+        self.is_existing_field_removable = None
+        self.field_sets = None
+        self.field_definitions = None
+        self.predefined_field_names = None
+        self.table_columns = None
+
+
+class TempDataStepCreation(StepCreation):
+    """
+    An object that contains criteria for creating a new temp data entry in an experiment.
+    """
+    plugin_path: str | None
+    """The temp data plugin path to run to populate the entry."""
+
+    def __init__(self):
+        super().__init__(ElnEntryType.TempData)
+        self.plugin_path = None
+
+
+class TextStepCreation(StepCreation):
+    """
+    An object that contains criteria for creating a new text entry in an experiment.
+    """
+    def __init__(self):
+        super().__init__(ElnEntryType.Text)

sapiopycommons/files/file_bridge.py

@@ -1,6 +1,7 @@
 import base64
 import io
 import urllib.parse
+from typing import Any
 
 from requests import Response
 from sapiopylib.rest.User import SapioUser
@@ -8,6 +9,36 @@ 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
@@ -137,3 +168,48 @@ 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]