sapiopycommons 2024.3.18a156__py3-none-any.whl → 2025.1.17a402__py3-none-any.whl

sapiopycommons/general/accession_service.py

@@ -0,0 +1,375 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any
+from weakref import WeakValueDictionary
+
+from sapiopylib.rest.User import SapioUser
+
+_STR_JAVA_TYPE = "java.lang.String"
+_INT_JAVA_TYPE = "java.lang.Integer"
+_BOOL_JAVA_TYPE = "java.lang.Boolean"
+
+
+class AbstractAccessionServiceOperator(ABC):
+    """
+    Abstract class to define an accession service operator.
+    The default one in sapiopycommon only includes the out of box operators.
+    More can be added via java plugins for global operators.
+    """
+
+    @property
+    @abstractmethod
+    def op_class_name(self) -> str:
+        pass
+
+    @property
+    @abstractmethod
+    def op_param_value_list(self) -> list[Any] | None:
+        pass
+
+    @property
+    @abstractmethod
+    def op_param_class_name_list(self) -> list[str] | None:
+        pass
+
+    @property
+    @abstractmethod
+    def default_accessor_name(self) -> str:
+        pass
+
+
+class AccessionWithPrefixSuffix(AbstractAccessionServiceOperator):
+    """
+    Local operator for accessioning prefix and suffix format.
+    """
+    _prefix: str | None
+    _suffix: str | None
+    _num_of_digits: int | None
+    _start_num: int
+    _strict_mode: bool
+
+    @property
+    def prefix(self):
+        return self._prefix
+
+    @property
+    def suffix(self):
+        return self._suffix
+
+    @property
+    def num_of_digits(self):
+        return self._num_of_digits
+
+    @property
+    def start_num(self):
+        return self._start_num
+
+    @property
+    def strict_mode(self):
+        return self._strict_mode
+
+    def __init__(self, prefix: str | None, suffix: str | None, num_of_digits: int | None = None,
+                 start_num: int = 1, strict_mode: bool = False):
+        if prefix is None:
+            prefix = ""
+        if suffix is None:
+            suffix = ""
+        self._prefix = prefix
+        self._suffix = suffix
+        self._num_of_digits = num_of_digits
+        self._start_num = start_num
+        self._strict_mode = strict_mode
+
+    @property
+    def op_param_value_list(self):
+        return [self._prefix, self._suffix, self._num_of_digits, self._start_num, self._strict_mode]
+
+    @property
+    def op_param_class_name_list(self):
+        return [_STR_JAVA_TYPE, _STR_JAVA_TYPE, _INT_JAVA_TYPE, _INT_JAVA_TYPE, _BOOL_JAVA_TYPE]
+
+    @property
+    def op_class_name(self):
+        return "com.velox.accessionservice.operators.AccessionWithPrefixSuffix"
+
+    @property
+    def default_accessor_name(self):
+        return "PREFIX_AND_SUFFIX" + "(" + self.prefix + "," + self.suffix + ")";
+
+
+class AccessionGlobalPrefixSuffix(AbstractAccessionServiceOperator):
+    """
+    Global operator for accessioning prefix and suffix format.
+    """
+    _prefix: str | None
+    _suffix: str | None
+    _num_of_digits: int | None
+    _start_num: int
+    _strict_mode: bool
+
+    @property
+    def prefix(self):
+        return self._prefix
+
+    @property
+    def suffix(self):
+        return self._suffix
+
+    @property
+    def num_of_digits(self):
+        return self._num_of_digits
+
+    @property
+    def start_num(self):
+        return self._start_num
+
+    @property
+    def strict_mode(self):
+        return self._strict_mode
+
+    def __init__(self, prefix: str | None, suffix: str | None, num_of_digits: int | None = None,
+                 start_num: int = 1, strict_mode: bool = False):
+        if prefix is None:
+            prefix = ""
+        if suffix is None:
+            suffix = ""
+        self._prefix = prefix
+        self._suffix = suffix
+        self._num_of_digits = num_of_digits
+        self._start_num = start_num
+        self._strict_mode = strict_mode
+
+    @property
+    def op_param_value_list(self):
+        return [self._prefix, self._suffix, self._num_of_digits, self._start_num, self._strict_mode]
+
+    @property
+    def op_param_class_name_list(self):
+        return [_STR_JAVA_TYPE, _STR_JAVA_TYPE, _INT_JAVA_TYPE, _INT_JAVA_TYPE, _BOOL_JAVA_TYPE]
+
+    @property
+    def op_class_name(self):
+        return "com.velox.accessionservice.operators.sapio.AccessionGlobalPrefixSuffix"
+
+    @property
+    def default_accessor_name(self):
+        return "PREFIX_AND_SUFFIX" + "(" + self._prefix + "," + self._suffix + ")"
+
+
+class AccessionNextBarcode(AbstractAccessionServiceOperator):
+    """
+    From Java description:
+    This will start accessioning at the getNextBarcode() when there's no system preference to be backward compatible.
+    However, once it completes setting the first ID, it will start increment by its own preference and disregards getNextBarcode().
+
+    Recommend using AccessionServiceBasicManager to accession next barcode.
+    To avoid ambiguity in preference cache.
+
+    This should not be used unless we are using something legacy such as plate mapping template record creation
+    (Note: not 3D plating, I'm talking about the older aliquoter).
+    """
+
+    @property
+    def op_param_value_list(self):
+        return []
+
+    @property
+    def op_param_class_name_list(self):
+        return []
+
+    @property
+    def op_class_name(self):
+        return "com.velox.accessionservice.operators.sapio.AccessionNextBarcode"
+
+    @property
+    def default_accessor_name(self):
+        return "Barcode"
+
+
+class AccessionRequestId(AbstractAccessionServiceOperator):
+    """
+    This class implements the accessioning operator for com.velox.sapioutils.shared.managers.DataRecordUtilManager.getNextRequestId()
+    and getNextRequestId(int numberOfCharacters).
+
+    Operation: For 4 characters start with A001, increment by 1 until A999. Then We use B001.
+    After Z999 we start with AA01 until we get to AA99, etc.
+
+    Exception: Skips I and O to prevent confusions with 1 and 0 when incrementing letters.
+
+    Properties:
+        numberOfCharacters: Number of characters maximum in the request ID.
+        accessorName: This is a legacy variable from drum.getNextIdListByMapName(), which allows setting different "accessorName" from old system. We need this for compability patch for converting these to the new preference format.
+    """
+    _num_of_characters: int
+    _accessor_name: str
+
+    @property
+    def num_of_characters(self):
+        return self._num_of_characters
+
+    @property
+    def accessor_name(self):
+        return self._accessor_name
+
+    def __init__(self, num_of_characters: int = 4, accessor_name: str = None):
+        self._num_of_characters = num_of_characters
+        if not accessor_name:
+            accessor_name = self.default_accessor_name
+        self._accessor_name = accessor_name
+
+    @property
+    def op_class_name(self):
+        return "com.velox.accessionservice.operators.sapio.AccessionRequestId"
+
+    @property
+    def op_param_value_list(self):
+        return [self._num_of_characters, self._accessor_name]
+
+    @property
+    def op_param_class_name_list(self):
+        return [_INT_JAVA_TYPE, _STR_JAVA_TYPE]
+
+    @property
+    def default_accessor_name(self):
+        return "SapioNextRequestIdMap"
+
+
+class AccessionServiceDescriptor:
+    """
+    Describes a single accession service's accessioning request
+
+    Attributes:
+        opClassName: The accession service operator class name as in Java
+        opParamValueList: Ordered list of parameter values to construct the accession service operator.
+        opParamClassNameList: Ordered list of FQCN of java classes in order of parameter value list.
+        dataTypeName: The data type to accession. Should be blank if opClassName resolves to a global operator.
+        dataFieldName: The data field to accession. Should be blank if opClassName resolves to a global operator.
+        accessorName: The accessor cache name to be used for accessioning.
+        numIds: The number of IDs to accession.
+    """
+    op: AbstractAccessionServiceOperator
+    dataTypeName: str | None
+    dataFieldName: str | None
+    accessorName: str
+    numIds: int
+
+    def __init__(self, accessor_name: str, op: AbstractAccessionServiceOperator, num_ids: int,
+                 data_type_name: str | None, data_field_name: str | None):
+        self.accessorName = accessor_name
+        self.op = op
+        self.dataTypeName = data_type_name
+        self.dataFieldName = data_field_name
+        self.numIds = num_ids
+
+    def to_json(self):
+        return {
+            "opClassName": self.op.op_class_name,
+            "opParamValueList": self.op.op_param_value_list,
+            "opParamClassNameList": self.op.op_param_class_name_list,
+            "accessorName": self.accessorName,
+            "numIds": self.numIds,
+            "dataTypeName": self.dataTypeName,
+            "dataFieldName": self.dataFieldName
+        }
+
+
+class AccessionService:
+    """
+    Provides Sapio Foundations Accession Service functionalities.
+    """
+    _user: SapioUser
+
+    __instances: WeakValueDictionary[SapioUser, AccessionService] = WeakValueDictionary()
+    __initialized: bool
+
+    @property
+    def user(self) -> SapioUser:
+        return self._user
+
+    def __new__(cls, user: SapioUser):
+        """
+        Observes singleton pattern per record model manager object.
+
+        :param user: The user that will make the webservice request to the application.
+        """
+        obj = cls.__instances.get(user)
+        if not obj:
+            obj = object.__new__(cls)
+            obj.__initialized = False
+            cls.__instances[user] = obj
+        return obj
+
+    def __init__(self, user: SapioUser):
+        if self.__initialized:
+            return
+        self._user = user
+        self.__initialized = True
+
+    def accession_with_config(self, data_type_name: str, data_field_name: str, num_ids: int) -> list[str]:
+        """
+        Accession with Configuration Manager => Accession Service configuration (This is not visible to regular users in SaaS)
+        """
+        payload = {
+            "dataTypeName": data_type_name,
+            "dataFieldName": data_field_name,
+            "numIds": num_ids
+        }
+        response = self.user.plugin_post("accessionservice/accession_with_config", payload=payload)
+        self.user.raise_for_status(response)
+        return list(response.json())
+
+    def accession_in_batch(self, descriptor: AccessionServiceDescriptor) -> list[str]:
+        """
+        This is the most flexible way to make use of accession service: directly via a descriptor object.
+        """
+        payload = descriptor.to_json()
+        response = self.user.plugin_post("accessionservice/accession", payload=payload)
+        self.user.raise_for_status(response)
+        return list(response.json())
+
+    def accession_next_request_id_list(self, num_of_characters: int, num_ids: int) -> list[str]:
+        """
+        Accession Request ID by old LIMS format. This is usually deprecated today.
+        :param num_of_characters: Number of characters minimum in request ID.
+        :param num_ids: Number of request IDs to accession.
+        """
+        op = AccessionRequestId(num_of_characters)
+        descriptor = AccessionServiceDescriptor(op.default_accessor_name, op, num_ids, None, None)
+        return self.accession_in_batch(descriptor)
+
+    def get_affixed_id_in_batch(self, data_type_name: str, data_field_name: str, num_ids: int, prefix: str | None,
+                                suffix: str | None, num_digits: int | None, start_num: int = 1) -> list[str]:
+        """
+        Get the batch affixed IDs that are maximal in cache and contiguious for a particular datatype.datafield under a given format.
+        :param data_type_name: The datatype name to look for max ID
+        :param data_field_name: The datafield name to look for max ID
+        :param num_ids: The number of IDs to accession.
+        :param prefix: leave it empty string "" if no prefix. Otherwise, specifies the prefix of ID.
+        :param suffix: leave it empty string "" if no suffix. Otherwise, specifies the suffix of ID.
+        :param num_digits: None if unlimited with no leading zeros.
+        :param start_num The number to begin accessioning if this is the first time.
+        :return:
+        """
+        op = AccessionWithPrefixSuffix(prefix, suffix, num_digits, start_num)
+        descriptor = AccessionServiceDescriptor(op.default_accessor_name, op, num_ids, data_type_name, data_field_name)
+        return self.accession_in_batch(descriptor)
+
+    def get_global_affixed_id_in_batch(
+            self, num_ids: int, prefix: str | None, suffix: str | None, num_digits: int | None, start_num: int = 1) -> list[str]:
+        """
+        Get the next numOfIds affixed IDs using system preference cache that's maximum across all datatype and datafields and maximal for the format.
+        This method allows users to customize a start number instead of always starting at 1.
+        :param num_ids: The number of IDs to accession.
+        :param prefix: leave it empty string "" if no prefix. Otherwise, specifies the prefix of ID.
+        :param suffix: leave it empty string "" if no suffix. Otherwise, specifies the suffix of ID.
+        :param num_digits: None if unlimited with no leading zeros.
+        :param start_num The number to begin accessioning if this is the first time.
+        """
+        op: AbstractAccessionServiceOperator
+        if not prefix and not suffix:
+            op = AccessionNextBarcode()
+        else:
+            op = AccessionGlobalPrefixSuffix(prefix, suffix, num_digits, start_num)
+        descriptor = AccessionServiceDescriptor(op.default_accessor_name, op, num_ids, None, None)
+        return self.accession_in_batch(descriptor)

sapiopycommons/general/aliases.py

@@ -1,14 +1,51 @@
 from collections.abc import Iterable
-from typing import Any
+from typing import Any, TypeAlias
 
+from sapiopylib.rest.User import SapioUser
 from sapiopylib.rest.pojo.DataRecord import DataRecord
-from sapiopylib.rest.utils.recordmodel.PyRecordModel import PyRecordModel
-from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedRecordModel, WrappedType
+from sapiopylib.rest.pojo.datatype.FieldDefinition import FieldType, AbstractVeloxFieldDefinition
+from sapiopylib.rest.pojo.eln.ElnExperiment import ElnExperiment
+from sapiopylib.rest.pojo.eln.ExperimentEntry import ExperimentEntry
+from sapiopylib.rest.pojo.eln.SapioELNEnums import ElnBaseDataType
+from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
+from sapiopylib.rest.utils.Protocols import ElnExperimentProtocol, ElnEntryStep
+from sapiopylib.rest.utils.recordmodel.PyRecordModel import PyRecordModel, AbstractRecordModel
+from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedRecordModel, WrappedType, WrapperField
 
-# Different forms that a record model could take.
-RecordModel = PyRecordModel | WrappedRecordModel | WrappedType
-# A record could be provided as either a DataRecord, PyRecordModel, or WrappedRecordModel (WrappedType).
-SapioRecord = DataRecord | RecordModel
+from sapiopycommons.general.exceptions import SapioException
+
+FieldValue: TypeAlias = int | float | str | bool | None
+"""Allowable values for fields in the system."""
+RecordModel: TypeAlias = PyRecordModel | AbstractRecordModel | WrappedRecordModel
+"""Different forms that a record model could take."""
+SapioRecord: TypeAlias = DataRecord | RecordModel
+"""A record could be provided as either a DataRecord, PyRecordModel, or WrappedRecordModel (WrappedType)."""
+RecordIdentifier: TypeAlias = SapioRecord | int
+"""A RecordIdentifier is either a record type or an integer for the record's record ID."""
+DataTypeIdentifier: TypeAlias = SapioRecord | type[WrappedType] | str
+"""A DataTypeIdentifier is either a SapioRecord, a record model wrapper type, or a string."""
+FieldIdentifier: TypeAlias = AbstractVeloxFieldDefinition | WrapperField | str | tuple[str, FieldType]
+"""A FieldIdentifier is either wrapper field from a record model wrapper, a string, or a tuple of string
+and field type."""
+FieldIdentifierKey: TypeAlias = WrapperField | str
+"""A FieldIdentifierKey is a FieldIdentifier, except it can't be a tuple, s tuples can't be used as keys in
+dictionaries.."""
+HasFieldWrappers: TypeAlias = type[WrappedType] | WrappedRecordModel
+"""An identifier for classes that have wrapper fields."""
+ExperimentIdentifier: TypeAlias = ElnExperimentProtocol | ElnExperiment | int
+"""An ExperimentIdentifier is either an experiment protocol, experiment, or an integer for the experiment's notebook
+ID."""
+ExperimentEntryIdentifier: TypeAlias = ElnEntryStep | ExperimentEntry | int
+"""An ExperimentEntryIdentifier is either an ELN entry step, experiment entry, or an integer for the entry's ID."""
+FieldMap: TypeAlias = dict[str, FieldValue]
+"""A field map is simply a dict of data field names to values. The purpose of aliasing this is to help distinguish
+any random dict in a webhook from one which is explicitly used for record fields."""
+FieldIdentifierMap: TypeAlias = dict[FieldIdentifierKey, FieldValue]
+"""A field identifier map is the same thing as a field map, except the keys can be field identifiers instead
+of just strings. Note that although one of the allowed field identifiers is a tuple, you can't use tuples as
+keys in a dictionary."""
+UserIdentifier: TypeAlias = SapioWebhookContext | SapioUser
+"""An identifier for classes from which a user object can be used for sending requests."""
 
 
 # FR-46064 - Initial port of PyWebhookUtils to sapiopycommons.
@@ -16,7 +53,8 @@ class AliasUtil:
     @staticmethod
     def to_data_record(record: SapioRecord) -> DataRecord:
         """
-        Convert a single DataRecord, PyRecordModel, or WrappedRecordModel to just a DataRecord
+        Convert a single DataRecord, PyRecordModel, or WrappedRecordModel to just a DataRecord.
+
         :return: The DataRecord of the input SapioRecord.
         """
         return record if isinstance(record, DataRecord) else record.get_data_record()
@@ -26,30 +64,233 @@ class AliasUtil:
         """
         Convert a list of variables that could either be DataRecords, PyRecordModels,
         or WrappedRecordModels to just DataRecords.
+
         :return: A list of DataRecords for the input records.
         """
         return [(x if isinstance(x, DataRecord) else x.get_data_record()) for x in records]
 
     @staticmethod
-    def to_record_ids(records: Iterable[int | SapioRecord]) -> list[int]:
+    def to_record_ids(records: Iterable[RecordIdentifier]) -> list[int]:
         """
         Convert a list of variables that could either be integers, DataRecords, PyRecordModels,
         or WrappedRecordModels to just integers (taking the record ID from the records).
+
         :return: A list of record IDs for the input records.
         """
-        return [(x if isinstance(x, int) else x.record_id) for x in records]
+        return [(AliasUtil.to_record_id(x)) for x in records]
 
     @staticmethod
-    def to_field_map_lists(records: Iterable[SapioRecord]) -> list[dict[str, Any]]:
+    def to_record_id(record: RecordIdentifier):
         """
-        Convert a list of variables that could either be DataRecords, PyRecordModels,
-        or WrappedRecordModels to a list of their field maps.
+        Convert a single variable that could be either an integer, DataRecord, PyRecordModel,
+        or WrappedRecordModel to just an integer (taking the record ID from the record).
+
+        :return: A record ID for the input record.
+        """
+        return record if isinstance(record, int) else record.record_id
+
+    @staticmethod
+    def to_data_type_name(value: DataTypeIdentifier, convert_eln_dts: bool = True) -> str:
+        """
+        Convert a given value to a data type name.
+
+        :param value: A value which is a string, record, or record model type.
+        :param convert_eln_dts: If true, convert ELN data types to their base data type name.
+        :return: A string of the data type name of the input value.
+        """
+        if isinstance(value, SapioRecord):
+            value = value.data_type_name
+        elif not isinstance(value, str):
+            value = value.get_wrapper_data_type_name()
+        if convert_eln_dts and ElnBaseDataType.is_eln_type(value):
+            return ElnBaseDataType.get_base_type(value).data_type_name
+        return value
+
+    @staticmethod
+    def to_data_type_names(values: Iterable[DataTypeIdentifier], return_set: bool = False,
+                           convert_eln_dts: bool = True) -> list[str] | set[str]:
+        """
+        Convert a given iterable of values to a list or set of data type names.
+
+        :param values: An iterable of values which are strings, records, or record model types.
+        :param return_set: If true, return a set instead of a list.
+        :param convert_eln_dts: If true, convert ELN data types to their base data type name.
+        :return: A list or set of strings of the data type name of the input value.
+        """
+        values = [AliasUtil.to_data_type_name(x, convert_eln_dts) for x in values]
+        return set(values) if return_set else values
+
+    @staticmethod
+    def to_singular_data_type_name(values: Iterable[DataTypeIdentifier], convert_eln_dts: bool = True) -> str:
+        """
+        Convert a given iterable of values to a singular data type name that they share. Throws an exception if more
+        than one data type name exists in the provided list of identifiers.
+
+        :param values: An iterable of values which are strings, records, or record model types.
+        :param convert_eln_dts: If true, convert ELN data types to their base data type name.
+        :return: The single data type name that the input vales share. Returns an empty string if an empty iterable
+            was provided.
+        """
+        if not values:
+            return ""
+        data_types: set[str] = AliasUtil.to_data_type_names(values, True, convert_eln_dts)
+        if len(data_types) > 1:
+            raise SapioException(f"Provided values contain multiple data types: {data_types}. "
+                                 f"Only expecting a single data type.")
+        return data_types.pop()
+
+    @staticmethod
+    def to_data_field_name(value: FieldIdentifier) -> str:
+        """
+        Convert an object that can be used to identify a data field to a data field name string.
+
+        :param value: An object that can be used to identify a data field.
+        :return: A string of the data field name of the input value.
+        """
+        if isinstance(value, tuple):
+            return value[0]
+        if isinstance(value, WrapperField):
+            return value.field_name
+        if isinstance(value, AbstractVeloxFieldDefinition):
+            return value.data_field_name
+        return value
+
+    @staticmethod
+    def to_data_field_names(values: Iterable[FieldIdentifier]) -> list[str]:
+        """
+        Convert an iterable of objects that can be used to identify data fields to a list of data field name strings.
+
+        :param values: An iterable of objects that can be used to identify a data field.
+        :return: A list of strings of the data field names of the input values.
+        """
+        return [AliasUtil.to_data_field_name(x) for x in values]
+
+    @staticmethod
+    def to_data_field_names_dict(values: dict[FieldIdentifierKey, Any]) -> dict[str, Any]:
+        """
+        Take a dictionary whose keys are field identifiers and convert them all to strings for the data field name.
+
+        :param values: A dictionary of field identifiers to field values.
+        :return: A dictionary of strings of the data field names to field values for the input values.
+        """
+        ret_dict: dict[str, FieldValue] = {}
+        for field, value in values.items():
+            ret_dict[AliasUtil.to_data_field_name(field)] = value
+        return ret_dict
+
+    @staticmethod
+    def to_data_field_names_list_dict(values: list[dict[FieldIdentifierKey, Any]]) -> list[dict[str, Any]]:
+        ret_list: list[dict[str, Any]] = []
+        for field_map in values:
+            ret_list.append(AliasUtil.to_data_field_names_dict(field_map))
+        return ret_list
+
+    @staticmethod
+    def to_field_type(field: FieldIdentifier, data_type: HasFieldWrappers | None = None) -> FieldType:
+        """
+        Convert a given field identifier to the field type for that field.
+
+        :param field: A string or WrapperField.
+        :param data_type: If the field is provided as a string, then a record model wrapper or wrapped record model
+            must be provided to determine the field type.
+        :return: The field type of the given field.
+        """
+        if isinstance(field, tuple):
+            return field[1]
+        if isinstance(field, WrapperField):
+            return field.field_type
+        for var in dir(data_type):
+            attr = getattr(data_type, var)
+            if isinstance(attr, WrapperField) and attr.field_name == field:
+                return attr.field_type
+        raise SapioException(f"The wrapper of data type \"{data_type.get_wrapper_data_type_name()}\" doesn't have a "
+                             f"field with the name \"{field}\",")
+
+    @staticmethod
+    def to_field_map(record: SapioRecord) -> FieldMap:
+        """
+        Convert a given record value to a field map. This includes the given RecordId of the given record.
+
+        :return: The field map for the input record.
+        """
+        if isinstance(record, DataRecord):
+            # noinspection PyTypeChecker
+            fields: FieldMap = record.get_fields()
+        else:
+            fields: FieldMap = record.fields.copy_to_dict()
+        fields["RecordId"] = AliasUtil.to_record_id(record)
+        return fields
+
+    @staticmethod
+    def to_field_map_lists(records: Iterable[SapioRecord]) -> list[FieldMap]:
+        """
+        Convert a list of variables that could either be DataRecords, PyRecordModels, or WrappedRecordModels
+        to a list of their field maps. This includes the given RecordId of the given records.
+
         :return: A list of field maps for the input records.
         """
-        field_map_list: list[dict[str, Any]] = []
+        field_map_list: list[FieldMap] = []
         for record in records:
-            if isinstance(record, DataRecord):
-                field_map_list.append(record.get_fields())
-            else:
-                field_map_list.append(record.fields.copy_to_dict())
+            field_map_list.append(AliasUtil.to_field_map(record))
         return field_map_list
+
+    @staticmethod
+    def to_notebook_id(experiment: ExperimentIdentifier) -> int:
+        """
+        Convert an object that identifies an ELN experiment to its notebook ID.
+
+        :return: The notebook ID for the experiment identifier.
+        """
+        if isinstance(experiment, int):
+            return experiment
+        if isinstance(experiment, ElnExperiment):
+            return experiment.notebook_experiment_id
+        return experiment.get_id()
+
+    @staticmethod
+    def to_notebook_ids(experiments: list[ExperimentIdentifier]) -> list[int]:
+        """
+        Convert a list of objects that identify ELN experiments to their notebook IDs.
+
+        :return: The list of notebook IDs for the experiment identifiers.
+        """
+        notebook_ids: list[int] = []
+        for experiment in experiments:
+            notebook_ids.append(AliasUtil.to_notebook_id(experiment))
+        return notebook_ids
+
+    @staticmethod
+    def to_entry_id(entry: ExperimentEntryIdentifier) -> int:
+        """
+        Convert an object that identifies an experiment entry to its entry ID.
+
+        :return: The entry ID for the entry identifier.
+        """
+        if isinstance(entry, int):
+            return entry
+        elif isinstance(entry, ExperimentEntry):
+            return entry.entry_id
+        elif isinstance(entry, ElnEntryStep):
+            return entry.get_id()
+        raise SapioException(f"Unrecognized entry identifier of type {type(entry)}")
+
+    @staticmethod
+    def to_entry_ids(entries: list[ExperimentEntryIdentifier]) -> list[int]:
+        """
+        Convert a list of objects that identify experiment entries to their entry IDs.
+
+        :return: The list of entry IDs for the entry identifiers.
+        """
+        entry_ids: list[int] = []
+        for entry in entries:
+            entry_ids.append(AliasUtil.to_entry_id(entry))
+        return entry_ids
+
+    @staticmethod
+    def to_sapio_user(context: UserIdentifier) -> SapioUser:
+        """
+        Convert an object that could be either a SapioUser or SapioWebhookContext to just a SapioUser.
+
+        :return: A SapioUser object.
+        """
+        return context if isinstance(context, SapioUser) else context.user