sapiopycommons 2024.8.27a310__py3-none-any.whl → 2024.8.28a313__py3-none-any.whl

sapiopycommons/chem/IndigoMolecules.py

@@ -6,7 +6,6 @@ indigo = Indigo()
 renderer = IndigoRenderer(indigo)
 indigo.setOption("render-output-format", "svg")
 indigo.setOption("ignore-stereochemistry-errors", True)
-indigo.setOption("render-stereo-style", "ext")
 indigo.setOption("aromaticity-model", "generic")
 indigo.setOption("render-coloring", True)
 indigo_inchi = IndigoInchi(indigo);

sapiopycommons/chem/Molecules.py

@@ -181,7 +181,6 @@ def mol_to_sapio_substance(mol: Mol, include_stereoisomers: bool = False,
     # We need to test the INCHI can be loaded back to indigo.
     indigo_mol = indigo.loadMolecule(molBlock)
     indigo_mol.aromatize()
-    indigo_inchi.resetOptions()
     indigo_inchi_str = indigo_inchi.getInchi(indigo_mol)
     molecule["inchi"] = indigo_inchi_str
     indigo_inchi_key_str = indigo_inchi.getInchiKey(indigo_inchi_str)

sapiopycommons/datatype/attachment_util.py

@@ -1,9 +1,10 @@
 import io
 
-from sapiopylib.rest.DataMgmtService import DataMgmtServer
+from sapiopylib.rest.User import SapioUser
+from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
 from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedType
 
-from sapiopycommons.general.aliases import AliasUtil, SapioRecord, UserIdentifier
+from sapiopycommons.general.aliases import AliasUtil, SapioRecord
 from sapiopycommons.general.exceptions import SapioException
 from sapiopycommons.recordmodel.record_handler import RecordHandler
 
@@ -11,32 +12,31 @@ from sapiopycommons.recordmodel.record_handler import RecordHandler
 # FR-46064 - Initial port of PyWebhookUtils to sapiopycommons.
 class AttachmentUtil:
     @staticmethod
-    def get_attachment_bytes(context: UserIdentifier, attachment: SapioRecord) -> bytes:
+    def get_attachment_bytes(context: SapioWebhookContext, attachment: SapioRecord) -> bytes:
         """
         Get the data bytes for the given attachment record. Makes a webservice call to retrieve the data.
 
-        :param context: The current webhook context or a user object to send requests from.
+        :param context: The current webhook context.
         :param attachment: The attachment record.
         :return: The bytes for the attachment's file data.
         """
         attachment = AliasUtil.to_data_record(attachment)
-        dr_man = DataMgmtServer.get_data_record_manager(AliasUtil.to_sapio_user(context))
         with io.BytesIO() as data_sink:
             def consume_data(chunk: bytes):
                 data_sink.write(chunk)
-            dr_man.get_attachment_data(attachment, consume_data)
+            context.data_record_manager.get_attachment_data(attachment, consume_data)
             data_sink.flush()
             data_sink.seek(0)
             file_bytes = data_sink.read()
         return file_bytes
 
     @staticmethod
-    def set_attachment_bytes(context: UserIdentifier, attachment: SapioRecord,
+    def set_attachment_bytes(context: SapioWebhookContext, attachment: SapioRecord,
                              file_name: str, file_bytes: bytes) -> None:
         """
         Set the attachment data for a given attachment record. Makes a webservice call to set the data.
 
-        :param context: The current webhook context or a user object to send requests from.
+        :param context: The current webhook context.
         :param attachment: The attachment record. Must be an existing data record that is an attachment type.
         :param file_name: The name of the attachment.
         :param file_bytes: The bytes of the attachment data.
@@ -45,12 +45,11 @@ class AttachmentUtil:
             raise SapioException("Provided record cannot have its attachment data set, as it does not exist in the "
                                  "system yet.")
         attachment = AliasUtil.to_data_record(attachment)
-        dr_man = DataMgmtServer.get_data_record_manager(AliasUtil.to_sapio_user(context))
         with io.BytesIO(file_bytes) as stream:
-            dr_man.set_attachment_data(attachment, file_name, stream)
+            context.data_record_manager.set_attachment_data(attachment, file_name, stream)
 
     @staticmethod
-    def create_attachment(context: UserIdentifier, file_name: str, file_bytes: bytes,
+    def create_attachment(context: SapioWebhookContext | SapioUser, file_name: str, file_bytes: bytes,
                           wrapper_type: type[WrappedType]) -> WrappedType:
         """
         Create an attachment data type and initialize its attachment bytes at the same time.

sapiopycommons/eln/experiment_handler.py

@@ -1,12 +1,7 @@
-from __future__ import annotations
-
 import time
 from collections.abc import Mapping, Iterable
-from weakref import WeakValueDictionary
 
-from sapiopylib.rest.DataMgmtService import DataMgmtServer
 from sapiopylib.rest.ELNService import ElnManager
-from sapiopylib.rest.User import SapioUser
 from sapiopylib.rest.pojo.DataRecord import DataRecord
 from sapiopylib.rest.pojo.eln.ElnExperiment import ElnExperiment, TemplateExperimentQueryPojo, ElnTemplate, \
     InitializeNotebookExperimentPojo, ElnExperimentUpdateCriteria
@@ -21,10 +16,8 @@ from sapiopylib.rest.utils.Protocols import ElnEntryStep, ElnExperimentProtocol
 from sapiopylib.rest.utils.recordmodel.PyRecordModel import PyRecordModel
 from sapiopylib.rest.utils.recordmodel.RecordModelManager import RecordModelInstanceManager, RecordModelManager
 from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedType
-from sapiopylib.rest.utils.recordmodel.properties import Child
 
-from sapiopycommons.general.aliases import AliasUtil, SapioRecord, ExperimentIdentifier, UserIdentifier, \
-    DataTypeIdentifier, RecordModel
+from sapiopycommons.general.aliases import AliasUtil, SapioRecord
 from sapiopycommons.general.exceptions import SapioException
 
 Step = str | ElnEntryStep
@@ -34,8 +27,7 @@ itself."""
 
 # FR-46064 - Initial port of PyWebhookUtils to sapiopycommons.
 class ExperimentHandler:
-    user: SapioUser
-    context: SapioWebhookContext | None
+    context: SapioWebhookContext
     """The context that this handler is working from."""
 
     # Basic experiment info from the context.
@@ -85,103 +77,44 @@ class ExperimentHandler:
                                     ElnExperimentStatus.Canceled]
     """The set of statuses that an ELN experiment could have and be considered locked."""
 
-    __instances: WeakValueDictionary[str, ExperimentHandler] = WeakValueDictionary()
-    __initialized: bool
-
-    def __new__(cls, context: UserIdentifier, experiment: ExperimentIdentifier | SapioRecord | None = None):
-        """
-        :param context: The current webhook context or a user object to send requests from.
-        :param experiment: If an experiment is provided that is separate from the experiment that is in the context,
-            that experiment will be used by this ExperimentHandler instead. An experiment can be provided in various
-            forms, including an ElnExperiment, ElnExperimentProtocol, an experiment record, or a notebook experiment ID.
-        """
-        param_results = cls.__parse_params(context, experiment)
-        user = param_results[0]
-        experiment = param_results[2]
-        key = f"{user.__hash__()}:{experiment.notebook_experiment_id}"
-        obj = cls.__instances.get(key)
-        if not obj:
-            obj = object.__new__(cls)
-            obj.__initialized = False
-            cls.__instances[key] = obj
-        return obj
-
-    def __init__(self, context: UserIdentifier, experiment: ExperimentIdentifier | SapioRecord | None = None):
+    def __init__(self, context: SapioWebhookContext, experiment: ElnExperiment | None = None):
         """
         Initialization will throw an exception if there is no ELN Experiment in the provided context and no experiment
         is provided.
 
-        :param context: The current webhook context or a user object to send requests from.
+        :param context: The current webhook context.
         :param experiment: If an experiment is provided that is separate from the experiment that is in the context,
-            that experiment will be used by this ExperimentHandler instead. An experiment can be provided in various
-            forms, including an ElnExperiment, ElnExperimentProtocol, an experiment record, or a notebook experiment ID.
+            that experiment will be used by this ExperimentHandler instead.
         """
-        param_results = self.__parse_params(context, experiment)
-        self.user = param_results[0]
-        self.context = param_results[1]
-        experiment = param_results[2]
+        # FR-46495 - Allow the init function of ExperimentHandler to take in an ElnExperiment that is separate from the
+        # context.
+        if context.eln_experiment is None and experiment is None:
+            raise SapioException("Cannot initialize ExperimentHandler. No ELN Experiment in the context.")
+        if context.eln_experiment == experiment:
+            experiment = None
+        self.context = context
 
         # Get the basic information about this experiment that already exists in the context and is often used.
-        self.__eln_exp = experiment
-        self.__protocol = ElnExperimentProtocol(experiment, self.user)
+        self.__eln_exp = experiment if experiment else context.eln_experiment
+        self.__protocol = ElnExperimentProtocol(experiment, context.user) if experiment else context.active_protocol
         self.__exp_id = self.__protocol.get_id()
 
         # Grab various managers that may be used.
-        self.__eln_man = DataMgmtServer.get_eln_manager(self.user)
-        self.__inst_man = RecordModelManager(self.user).instance_manager
+        self.__eln_man = context.eln_manager
+        self.__inst_man = RecordModelManager(context.user).instance_manager
 
         # Create empty caches to fill when necessary.
         self.__steps = {}
         self.__step_options = {}
         # CR-46330: Cache any experiment entry information that might already exist in the context.
         self.__queried_all_steps = False
-        # We can only trust the entries in the context if the experiment that this handler is for is the same as the
-        # one from the context.
-        if self.context is not None and self.context.eln_experiment == experiment:
-            if self.context.experiment_entry is not None:
-                self.__steps.update({self.context.active_step.get_name(): self.context.active_step})
-            if self.context.experiment_entry_list is not None:
-                for entry in self.context.experiment_entry_list:
-                    self.__steps.update({entry.entry_name: ElnEntryStep(self.__protocol, entry)})
-
-    @staticmethod
-    def __parse_params(context: UserIdentifier, experiment: ExperimentIdentifier | SapioRecord | None = None) \
-            -> tuple[SapioUser, SapioWebhookContext | None, ElnExperiment]:
-        if isinstance(context, SapioWebhookContext):
-            user = context.user
-            context = context
-        else:
-            user = context
-            context = None
-        if context is not None and context.eln_experiment is not None and experiment is None:
-            experiment = context.eln_experiment
-        # FR-46495 - Allow the init function of ExperimentHandler to take in an ElnExperiment that is separate from the
-        # context.
-        # CR-37038 - Allow other experiment object types to be provided. Convert them all down to ElnExperiment.
-        if (context is None or context.eln_experiment is None) and experiment is not None:
-            eln_manager = DataMgmtServer.get_eln_manager(user)
-            # If this object is already an ElnExperiment, do nothing.
-            if isinstance(experiment, ElnExperiment):
-                pass
-            # If this object is an ElnExperimentProtocol, then we can get the ElnExperiment from the object.
-            elif isinstance(experiment, ElnExperimentProtocol):
-                experiment: ElnExperiment = experiment.eln_experiment
-            # If this object is an integer, assume it is a notebook ID that we can query the system with.
-            elif isinstance(experiment, int):
-                notebook_id: int = experiment
-                experiment: ElnExperiment = eln_manager.get_eln_experiment_by_id(notebook_id)
-                if not experiment:
-                    raise SapioException(f"No experiment with notebook ID {notebook_id} located in the system.")
-            # If this object is a record, assume it is an experiment record that we can query the system with.
-            else:
-                record_id: int = AliasUtil.to_record_ids([experiment])[0]
-                experiment: ElnExperiment = eln_manager.get_eln_experiment_by_record_id(record_id)
-                if not experiment:
-                    raise SapioException(f"No experiment with record ID {record_id} located in the system.")
+        # We can only trust the entries in the context if no experiment was given as an input parameter.
         if experiment is None:
-            raise SapioException("Cannot initialize ExperimentHandler. No ELN Experiment found in the provided parameters.")
-
-        return user, context, experiment
+            if context.experiment_entry is not None:
+                self.__steps.update({context.active_step.get_name(): context.active_step})
+            if context.experiment_entry_list is not None:
+                for entry in context.experiment_entry_list:
+                    self.__steps.update({entry.entry_name: ElnEntryStep(self.__protocol, entry)})
 
     # FR-46495: Split the creation of the experiment in launch_experiment into a create_experiment function.
     @staticmethod
@@ -330,7 +263,11 @@ class ExperimentHandler:
         :return: The data record for this experiment. None if it has no record.
         """
         if not hasattr(self, "_ExperimentHandler__exp_record"):
-            self.__exp_record = self.__protocol.get_record()
+            drm = self.context.data_record_manager
+            dt = self.__eln_exp.experiment_data_type_name
+            results = drm.query_data_records_by_id(dt, [self.__eln_exp.experiment_record_id]).result_list
+            # PR-46504: Set the exp_record to None if there are no results.
+            self.__exp_record = results[0] if results else None
         if self.__exp_record is None and exception_on_none:
             raise SapioException(f"Experiment record not found for experiment with ID {self.__exp_id}.")
         return self.__exp_record
@@ -530,7 +467,7 @@ class ExperimentHandler:
             ret_list.append(step)
         return ret_list
 
-    def get_all_steps(self, data_type: DataTypeIdentifier | None = None) -> list[ElnEntryStep]:
+    def get_all_steps(self, data_type: str | type[WrappedType] | None = None) -> list[ElnEntryStep]:
         """
         Get a list of every entry in the experiment. Optionally filter the returned entries by a data type.
 
@@ -546,7 +483,8 @@ class ExperimentHandler:
         all_steps: list[ElnEntryStep] = self.__protocol.get_sorted_step_list()
         if data_type is None:
             return all_steps
-        data_type: str = AliasUtil.to_data_type_name(data_type)
+        if not isinstance(data_type, str):
+            data_type: str = data_type.get_wrapper_data_type_name()
         return [x for x in all_steps if data_type in x.get_data_type_names()]
 
     def get_step_records(self, step: Step) -> list[DataRecord]:
@@ -598,10 +536,6 @@ class ExperimentHandler:
             The records may be provided as either DataRecords, PyRecordModels, or WrappedRecordModels.
         """
         step = self.__to_eln_step(step)
-        dt: str = AliasUtil.to_singular_data_type_name(records)
-        if dt != step.get_data_type_names()[0]:
-            raise SapioException(f"Cannot add {dt} records to entry {step.get_name()} of type "
-                                 f"{step.get_data_type_names()[0]}.")
         step.add_records(AliasUtil.to_data_records(records))
 
     def remove_step_records(self, step: Step, records: Iterable[SapioRecord]) -> None:
@@ -620,10 +554,6 @@ class ExperimentHandler:
             The records may be provided as either DataRecords, PyRecordModels, or WrappedRecordModels.
         """
         step = self.__to_eln_step(step)
-        dt: str = AliasUtil.to_singular_data_type_name(records)
-        if dt != step.get_data_type_names()[0]:
-            raise SapioException(f"Cannot remove {dt} records from entry {step.get_name()} of type "
-                                 f"{step.get_data_type_names()[0]}.")
         step.remove_records(AliasUtil.to_data_records(records))
 
     def set_step_records(self, step: Step, records: Iterable[SapioRecord]) -> None:
@@ -647,13 +577,11 @@ class ExperimentHandler:
             The records may be provided as either DataRecords, PyRecordModels, or WrappedRecordModels.
         """
         step = self.__to_eln_step(step)
-        dt: str = AliasUtil.to_singular_data_type_name(records)
-        if dt != step.get_data_type_names()[0]:
-            raise SapioException(f"Cannot set {dt} records for entry {step.get_name()} of type "
-                                 f"{step.get_data_type_names()[0]}.")
         step.set_records(AliasUtil.to_data_records(records))
 
     # FR-46496 - Provide alias of set_step_records for use with form entries.
+    # TODO: Provide a similar aliased function for attachment entries once sapiopylib allows setting multiple
+    #  attachments to an attachment step.
     def set_form_record(self, step: Step, record: SapioRecord) -> None:
         """
         Sets the record for a form entry.
@@ -671,8 +599,7 @@ class ExperimentHandler:
         self.set_step_records(step, [record])
 
     # FR-46496 - Provide functions for adding and removing rows from an ELN data type entry.
-    def add_eln_rows(self, step: Step, count: int, wrapper_type: type[WrappedType] | None = None) \
-            -> list[PyRecordModel | WrappedType]:
+    def add_eln_rows(self, step: Step, count: int) -> list[PyRecordModel]:
         """
         Add rows to an ELNExperimentDetail or ELNSampleDetail table entry. The rows will not appear in the system
         until a record manager store and commit has occurred.
@@ -684,37 +611,15 @@ class ExperimentHandler:
             The step may be provided as either a string for the name of the step or an ElnEntryStep.
             If given a name, throws an exception if no step of the given name exists in the experiment.
         :param count: The number of new rows to add to the entry.
-        :param wrapper_type: Optionally wrap the ELN data type in a record model wrapper. If not provided, returns
-            an unwrapped PyRecordModel.
         :return: A list of the newly created rows.
         """
         step = self.__to_eln_step(step)
         if step.eln_entry.entry_type != ElnEntryType.Table:
             raise SapioException("The provided step is not a table entry.")
         dt: str = step.get_data_type_names()[0]
-        if not ElnBaseDataType.is_eln_type(dt):
+        if not self.__is_eln_type(dt):
             raise SapioException("The provided step is not an ELN data type entry.")
-        records: list[PyRecordModel] = self.__inst_man.add_new_records(dt, count)
-        if wrapper_type:
-            return self.__inst_man.wrap_list(records, wrapper_type)
-        return records
-
-    def add_eln_row(self, step: Step, wrapper_type: type[WrappedType] | None = None) -> PyRecordModel | WrappedType:
-        """
-        Add a row to an ELNExperimentDetail or ELNSampleDetail table entry. The row will not appear in the system
-        until a record manager store and commit has occurred.
-
-        If no step functions have been called before and a step is being searched for by name, queries for the
-        list of steps in the experiment and caches them.
-
-        :param step:
-            The step may be provided as either a string for the name of the step or an ElnEntryStep.
-            If given a name, throws an exception if no step of the given name exists in the experiment.
-        :param wrapper_type: Optionally wrap the ELN data type in a record model wrapper. If not provided, returns
-            an unwrapped PyRecordModel.
-        :return: The newly created row.
-        """
-        return self.add_eln_rows(step, 1, wrapper_type)[0]
+        return self.__inst_man.add_new_records(dt, count)
 
     def remove_eln_rows(self, step: Step, records: list[SapioRecord]) -> None:
         """
@@ -736,12 +641,10 @@ class ExperimentHandler:
         """
         step = self.__to_eln_step(step)
         dt: str = step.get_data_type_names()[0]
-        if not ElnBaseDataType.is_eln_type(dt):
+        if not self.__is_eln_type(dt):
             raise SapioException("The provided step is not an ELN data type entry.")
-        record_dt: str = AliasUtil.to_singular_data_type_name(records)
-        if record_dt != dt:
-            raise SapioException(f"Cannot remove {dt} records from entry {step.get_name()} of type "
-                                 f"{step.get_data_type_names()[0]}.")
+        if any([x.data_type_name != dt for x in records]):
+            raise SapioException("Not all of the provided records match the data type of the step.")
         # If any rows were provided as data records, turn them into record models before deleting them, as otherwise
         # this function would need to make a webservice call to do the deletion.
         data_records: list[DataRecord] = []
@@ -755,59 +658,16 @@ class ExperimentHandler:
             for record in record_models:
                 record.delete()
 
-    def remove_eln_row(self, step: Step, record: SapioRecord) -> None:
-        """
-        Remove a row from an ELNExperimentDetail or ELNSampleDetail table entry. ELN data type table entries display all
-        records in the system that match the entry's data type. This means that removing rows from an ELN data type
-        table entry is equivalent to deleting the records for the rows.
-
-        The row will not be deleted in the system until a record manager store and commit has occurred.
-
-        If no step functions have been called before and a step is being searched for by name, queries for the
-        list of steps in the experiment and caches them.
-
-        :param step:
-            The step may be provided as either a string for the name of the step or an ElnEntryStep.
-            If given a name, throws an exception if no step of the given name exists in the experiment.
-        :param record:
-            The record to remove from the given step.
-            The record may be provided as either a DataRecord, PyRecordModel, or WrappedRecordModel.
-        """
-        self.remove_eln_row(step, [record])
-
-    def add_sample_details(self, step: Step, samples: list[RecordModel], wrapper_type: type[WrappedType]) \
-            -> list[PyRecordModel | WrappedType]:
-        """
-        Add sample details to a sample details entry while relating them to the input sample records.
-
-        :param step:
-            The step may be provided as either a string for the name of the step or an ElnEntryStep.
-            If given a name, throws an exception if no step of the given name exists in the experiment.
-        :param samples: The sample records to add the sample details to.
-        :param wrapper_type: Optionally wrap the sample details in a record model wrapper. If not provided, returns
-            an unwrapped PyRecordModel.
-        :return: The newly created sample details. The indices of the samples in the input list match the index of the
-            sample details in this list that they are related to.
-        """
-        step = self.__to_eln_step(step)
-        if step.eln_entry.entry_type != ElnEntryType.Table:
-            raise SapioException("The provided step is not a table entry.")
-        dt: str = step.get_data_type_names()[0]
-        if not ElnBaseDataType.is_eln_type(dt) or ElnBaseDataType.get_base_type(dt) != ElnBaseDataType.SAMPLE_DETAIL:
-            raise SapioException("The provided step is not an ELNSampleDetail entry.")
-        records: list[PyRecordModel] = []
-        for sample in samples:
-            if sample.data_type_name != "Sample":
-                raise SapioException(f"Received a {sample.data_type_name} record when Sample records were expected.")
-            detail: PyRecordModel = sample.add(Child.of_type_name(dt))
-            detail.set_field_values({
-                "SampleId": sample.get_field_value("SampleId"),
-                "OtherSampleId": sample.get_field_value("OtherSampleId")
-            })
-            records.append(detail)
-        if wrapper_type:
-            return self.__inst_man.wrap_list(records, wrapper_type)
-        return records
+    # TODO: Remove and use the function of the same name in ElnBaseDataType in the future. Currently this function is
+    #  bugged in sapiopylib and is comparing against base_type.name instead of base_type.value.
+    @staticmethod
+    def __is_eln_type(data_type: str):
+        if data_type is None or not data_type:
+            return False
+        for base_type in ElnBaseDataType:
+            if data_type.lower().startswith(base_type.value.lower()):
+                return True
+        return False
 
     def update_step(self, step: Step,
                     entry_name: str | None = None,
@@ -1096,27 +956,6 @@ class ExperimentHandler:
             step.unlock_step()
             step.eln_entry.entry_status = ExperimentEntryStatus.UnlockedChangesRequired
 
-    def disable_step(self, step: Step) -> None:
-        """
-        Set the status of the input step to Disabled. This is the state that entries are in when they are waiting for
-        entries that they are dependent upon to be submitted before they can be enabled. If you have unsubmitted an
-        entry and want its dependent entries to be locked again, then you would use this to set their status to
-        disabled.
-
-        Makes a webservice call to update the step. Checks if the step is already unlocked, and does nothing if so.
-
-        If no step functions have been called before and a step is being searched for by name, queries for the
-        list of steps in the experiment and caches them.
-
-        :param step:
-            The step to disable.
-            The step may be provided as either a string for the name of the step or an ElnEntryStep.
-            If given a name, throws an exception if no step of the given name exists in the experiment.
-        """
-        step = self.__to_eln_step(step)
-        if step.eln_entry.entry_status in self.__ENTRY_LOCKED_STATUSES:
-            self.update_step(step, entry_status=ExperimentEntryStatus.Disabled)
-
     def step_is_submitted(self, step: Step) -> bool:
         """
         Determine if the input step has already been submitted.

sapiopycommons/files/complex_data_loader.py

@@ -1,13 +1,12 @@
 import io
 
 from sapiopylib.rest.User import SapioUser
-
-from sapiopycommons.general.aliases import UserIdentifier, AliasUtil
+from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
 
 
 class CDL:
     @staticmethod
-    def load_cdl(context: UserIdentifier, config_name: str, file_name: str, file_data: bytes | str) \
+    def load_cdl(context: SapioWebhookContext | SapioUser, config_name: str, file_name: str, file_data: bytes | str) \
             -> list[int]:
         """
         Create data records from a file using one of the complex data loader (CDL) configurations in the system.
@@ -23,8 +22,8 @@ class CDL:
             "configName": config_name,
             "fileName": file_name
         }
-        user: SapioUser = AliasUtil.to_sapio_user(context)
-        with io.BytesIO(file_data.encode() if isinstance(file_data, str) else file_data) as data_stream:
+        user: SapioUser = context if isinstance(context, SapioUser) else context.user
+        with io.StringIO(file_data) if isinstance(file_data, str) else io.BytesIO(file_data) as data_stream:
             response = user.post_data_stream(sub_path, params=params, data_stream=data_stream)
         user.raise_for_status(response)
         # The response content is returned as bytes for a comma separated string of record IDs.

sapiopycommons/files/file_bridge.py

@@ -4,21 +4,19 @@ import urllib.parse
 
 from requests import Response
 from sapiopylib.rest.User import SapioUser
-
-from sapiopycommons.general.aliases import UserIdentifier, AliasUtil
+from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
 
 
 # FR-46064 - Initial port of PyWebhookUtils to sapiopycommons.
 class FileBridge:
     @staticmethod
-    def read_file(context: UserIdentifier, bridge_name: str, file_path: str,
+    def read_file(context: SapioWebhookContext | SapioUser, bridge_name: str, file_path: str,
                   base64_decode: bool = True) -> bytes:
         """
         Read a file from 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 bridge_name: The name of the bridge to use.
         :param file_path: The path to read the file from.
         :param base64_decode: If true, base64 decode the file. Files are by default base64 encoded when retrieved from
             FileBridge.
@@ -28,7 +26,7 @@ class FileBridge:
         params = {
             'Filepath': f"bridge://{bridge_name}/{file_path}"
         }
-        user: SapioUser = AliasUtil.to_sapio_user(context)
+        user: SapioUser = context if isinstance(context, SapioUser) else context.user
         response = user.get(sub_path, params)
         user.raise_for_status(response)
 
@@ -38,14 +36,13 @@ class FileBridge:
         return ret_val
 
     @staticmethod
-    def write_file(context: UserIdentifier, bridge_name: str, file_path: str,
+    def write_file(context: SapioWebhookContext | SapioUser, bridge_name: str, file_path: str,
                    file_data: bytes | str) -> None:
         """
         Write a file to 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 bridge_name: The name of the bridge to use.
         :param file_path: The path to write the file to. If a file already exists at the given path then the file is
             overwritten.
         :param file_data: A string or bytes of the file to be written.
@@ -54,43 +51,41 @@ class FileBridge:
         params = {
             'Filepath': f"bridge://{bridge_name}/{file_path}"
         }
-        user: SapioUser = AliasUtil.to_sapio_user(context)
-        with io.BytesIO(file_data.encode() if isinstance(file_data, str) else file_data) as data_stream:
+        user: SapioUser = context if isinstance(context, SapioUser) else context.user
+        with io.StringIO(file_data) if isinstance(file_data, str) else io.BytesIO(file_data) as data_stream:
             response = user.post_data_stream(sub_path, params=params, data_stream=data_stream)
         user.raise_for_status(response)
 
     @staticmethod
-    def list_directory(context: UserIdentifier, bridge_name: str,
+    def list_directory(context: SapioWebhookContext | SapioUser, bridge_name: str,
                        file_path: str | None = "") -> list[str]:
         """
         List the contents of a FileBridge directory.
 
         :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 bridge_name: The name of the bridge to use.
         :param file_path: The path to read the directory from.
-        :return: A list of names of files and folders in the directory.
+        :return: A list of name of files and folders in the directory.
         """
         sub_path = '/ext/filebridge/listDirectory'
         params = {
             'Filepath': f"bridge://{bridge_name}/{file_path}"
         }
-        user: SapioUser = AliasUtil.to_sapio_user(context)
+        user: SapioUser = context if isinstance(context, SapioUser) else context.user
         response: Response = user.get(sub_path, params=params)
         user.raise_for_status(response)
 
         response_body: list[str] = response.json()
         path_length = len(f"bridge://{bridge_name}/")
-        return [urllib.parse.unquote(value)[path_length:] for value in response_body]
+        return [urllib.parse.unquote(value[path_length:]) for value in response_body]
 
     @staticmethod
-    def create_directory(context: UserIdentifier, bridge_name: str, file_path: str) -> None:
+    def create_directory(context: SapioWebhookContext | SapioUser, bridge_name: str, file_path: str) -> None:
         """
         Create a new 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 bridge_name: The name of the bridge to use.
         :param file_path: The path to create the directory at. If a directory already exists at the given path then an
             exception is raised.
         """
@@ -98,42 +93,40 @@ class FileBridge:
         params = {
             'Filepath': f"bridge://{bridge_name}/{file_path}"
         }
-        user: SapioUser = AliasUtil.to_sapio_user(context)
+        user: SapioUser = context if isinstance(context, SapioUser) else context.user
         response = user.post(sub_path, params=params)
         user.raise_for_status(response)
 
     @staticmethod
-    def delete_file(context: UserIdentifier, bridge_name: str, file_path: str) -> None:
+    def delete_file(context: SapioWebhookContext | SapioUser, bridge_name: str, file_path: str) -> None:
         """
         Delete an existing file 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 bridge_name: The name of the bridge to use.
         :param file_path: The path to the file to delete.
         """
         sub_path = '/ext/filebridge/deleteFile'
         params = {
             'Filepath': f"bridge://{bridge_name}/{file_path}"
         }
-        user: SapioUser = AliasUtil.to_sapio_user(context)
-        response = user.delete(sub_path, params=params)
+        user: SapioUser = context if isinstance(context, SapioUser) else context.user
+        response = user.post(sub_path, params=params)
         user.raise_for_status(response)
 
     @staticmethod
-    def delete_directory(context: UserIdentifier, bridge_name: str, file_path: str) -> None:
+    def delete_directory(context: SapioWebhookContext | SapioUser, bridge_name: str, file_path: str) -> None:
         """
         Delete an existing 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 bridge_name: The name of the bridge to use.
         :param file_path: The path to the directory to delete.
         """
         sub_path = '/ext/filebridge/deleteDirectory'
         params = {
             'Filepath': f"bridge://{bridge_name}/{file_path}"
         }
-        user: SapioUser = AliasUtil.to_sapio_user(context)
-        response = user.delete(sub_path, params=params)
+        user: SapioUser = context if isinstance(context, SapioUser) else context.user
+        response = user.post(sub_path, params=params)
         user.raise_for_status(response)