sapiopycommons 2024.8.7a303__py3-none-any.whl → 2024.8.19a305__py3-none-any.whl

sapiopycommons/eln/experiment_handler.py

@@ -1,5 +1,8 @@
+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
@@ -18,8 +21,9 @@ 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
+from sapiopycommons.general.aliases import AliasUtil, SapioRecord, ExperimentIdentifier, RecordModel
 from sapiopycommons.general.exceptions import SapioException
 
 Step = str | ElnEntryStep
@@ -80,7 +84,30 @@ class ExperimentHandler:
                                     ElnExperimentStatus.Canceled]
     """The set of statuses that an ELN experiment could have and be considered locked."""
 
-    def __init__(self, context: SapioWebhookContext | SapioUser, experiment: ExperimentIdentifier | SapioRecord | None = None):
+    __instances: WeakValueDictionary[str, ExperimentHandler] = WeakValueDictionary()
+    __initialized: bool
+
+    def __new__(cls, context: SapioWebhookContext | SapioUser,
+                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: SapioWebhookContext | SapioUser,
+                 experiment: ExperimentIdentifier | SapioRecord | None = None):
         """
         Initialization will throw an exception if there is no ELN Experiment in the provided context and no experiment
         is provided.
@@ -90,16 +117,51 @@ class ExperimentHandler:
             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 = self.__parse_params(context, experiment)
+        self.user = param_results[0]
+        self.context = param_results[1]
+        experiment = param_results[2]
+
+        # 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.__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
+
+        # 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: SapioWebhookContext | SapioUser,
+                       experiment: ExperimentIdentifier | SapioRecord | None = None) \
+            -> tuple[SapioUser, SapioWebhookContext | None, ElnExperiment]:
         if isinstance(context, SapioWebhookContext):
-            self.user = context.user
-            self.context = context
+            user = context.user
+            context = context
         else:
-            self.user = context
-            self.context = None
+            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 experiment is not None:
+        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
@@ -109,41 +171,19 @@ class ExperimentHandler:
             # 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 = context.eln_manager.get_eln_experiment_by_id(notebook_id)
+                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 = context.eln_manager.get_eln_experiment_by_record_id(record_id)
+                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.")
-        if (context is None or context.eln_experiment is None) and experiment is None:
-            raise SapioException("Cannot initialize ExperimentHandler. No ELN Experiment in the context.")
-        if context and context.eln_experiment == experiment:
-            experiment: ElnExperiment | None = None
-
-        # Get the basic information about this experiment that already exists in the context and is often used.
-        self.__eln_exp = experiment if experiment else context.eln_experiment
-        self.__protocol = ElnExperimentProtocol(experiment, self.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
-
-        # 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 no experiment was given as an input parameter.
         if experiment is None:
-            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)})
+            raise SapioException("Cannot initialize ExperimentHandler. No ELN Experiment found in the provided parameters.")
+
+        return user, context, experiment
 
     # FR-46495: Split the creation of the experiment in launch_experiment into a create_experiment function.
     @staticmethod
@@ -626,7 +666,8 @@ 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) -> list[PyRecordModel]:
+    def add_eln_rows(self, step: Step, count: int, wrapper_type: type[WrappedType] | None = None) \
+            -> list[PyRecordModel | WrappedType]:
         """
         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.
@@ -638,6 +679,8 @@ 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)
@@ -646,7 +689,27 @@ class ExperimentHandler:
         dt: str = step.get_data_type_names()[0]
         if not ElnBaseDataType.is_eln_type(dt):
             raise SapioException("The provided step is not an ELN data type entry.")
-        return self.__inst_man.add_new_records(dt, count)
+        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]
 
     def remove_eln_rows(self, step: Step, records: list[SapioRecord]) -> None:
         """
@@ -685,6 +748,60 @@ 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
+
     def update_step(self, step: Step,
                     entry_name: str | None = None,
                     related_entry_set: Iterable[int] | None = None,

sapiopycommons/files/file_bridge_handler.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from abc import abstractmethod, ABC
+from weakref import WeakValueDictionary
 
 from sapiopycommons.files.file_bridge import FileBridge
 from sapiopylib.rest.User import SapioUser
@@ -23,12 +24,32 @@ class FileBridgeHandler:
     __directories: dict[str, Directory]
     """A cache of directory file paths to Directory objects."""
 
+    __instances: WeakValueDictionary[str, FileBridgeHandler] = WeakValueDictionary()
+    __initialized: bool
+
+    def __new__(cls, context: SapioWebhookContext | SapioUser, bridge_name: str):
+        """
+        :param context: The current webhook context or a user object to send requests from.
+        """
+        user = context if isinstance(context, SapioUser) else context.user
+        key = f"{user.__hash__()}:{bridge_name}"
+        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: SapioWebhookContext | SapioUser, bridge_name: str):
         """
         :param context: The current webhook context or a user object to send requests from.
         :param bridge_name: The name of the bridge to communicate with. This is the "connection name" in the
             file bridge configurations.
         """
+        if self.__initialized:
+            return
+        self.__initialized = True
+
         self.user = context if isinstance(context, SapioUser) else context.user
         self.__bridge = bridge_name
         self.__file_cache = {}

sapiopycommons/files/file_util.py

@@ -1,4 +1,6 @@
 import io
+import warnings
+import zipfile
 
 import pandas
 from numpy import dtype
@@ -282,6 +284,20 @@ class FileUtil:
             file_bytes: bytes = buffer.getvalue()
         return file_bytes
 
+    @staticmethod
+    def zip_files(files: dict[str, str | bytes]) -> bytes:
+        """
+        Create a zip file for a collection of files.
+
+        :param files: A dictionary of file name to file data as a string or bytes.
+        :return: The bytes for a zip file containing the input files.
+        """
+        zip_buffer: io.BytesIO = io.BytesIO()
+        with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zip_file:
+            for file_name, file_data in files.items():
+                zip_file.writestr(file_name, file_data)
+        return zip_buffer.getvalue()
+
     # Deprecated functions:
 
     # FR-46097 - Add write file request shorthand functions to FileUtil.
@@ -299,6 +315,8 @@ class FileUtil:
         :param request_context: Context that will be returned to the webhook server in the client callback result.
         :return: A SapioWebhookResult with the write request as its client callback request.
         """
+        warnings.warn("FileUtil.write_file is deprecated as of 24.5+. Use CallbackUtil.write_file instead.",
+                      DeprecationWarning)
         return SapioWebhookResult(True, client_callback_request=WriteFileRequest(file_bytes, file_name,
                                                                                  request_context))
 
@@ -315,6 +333,8 @@ class FileUtil:
         :param request_context: Context that will be returned to the webhook server in the client callback result.
         :return: A SapioWebhookResult with the write request as its client callback request.
         """
+        warnings.warn("FileUtil.write_files is deprecated as of 24.5+. Use CallbackUtil.write_file instead.",
+                      DeprecationWarning)
         return SapioWebhookResult(True, client_callback_request=MultiFileRequest(files, request_context))
 
     @staticmethod
@@ -342,6 +362,8 @@ class FileUtil:
             1 - The file name of the requested file if the user provided one.
             2 - The file bytes of the requested file if the user provided one.
         """
+        warnings.warn("FileUtil.request_file is deprecated as of 24.5+. Use CallbackUtil.request_file instead.",
+                      DeprecationWarning)
         client_callback = context.client_callback_result
         result_context: str | None = client_callback.callback_context_data if client_callback else None
         # If the user cancels, terminate the interaction.
@@ -394,6 +416,8 @@ class FileUtil:
             May also contain a result that will terminate the client interaction if the user canceled the prompt.
             1 - A dictionary that maps the file names to the file bytes for each provided file.
         """
+        warnings.warn("FileUtil.request_files is deprecated as of 24.5+. Use CallbackUtil.request_files instead.",
+                      DeprecationWarning)
         client_callback = context.client_callback_result
         result_context: str | None = client_callback.callback_context_data if client_callback else None
         # If the user cancels, terminate the interaction.
@@ -436,7 +460,7 @@ class FileUtil:
         if len(allowed_extensions) != 0:
             matches: bool = False
             for ext in allowed_extensions:
-                if file_path.endswith("." + ext):
+                if file_path.endswith("." + ext.lstrip(".")):
                     matches = True
                     break
             if matches is False:

sapiopycommons/files/file_validator.py

@@ -12,6 +12,7 @@ from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
 from sapiopycommons.callbacks.callback_util import CallbackUtil
 from sapiopycommons.files.file_data_handler import FileDataHandler, FilterList
 from sapiopycommons.general.custom_report_util import CustomReportUtil
+from sapiopycommons.general.exceptions import SapioUserCancelledException
 from sapiopycommons.general.time_util import TimeUtil
 
 
@@ -82,7 +83,7 @@ class FileValidator:
     def build_violation_report(self, context: SapioWebhookContext | SapioUser,
                                rule_violations: dict[int, list[ValidationRule]]) -> None:
         """
-        Build a simple report of any rule violations in the file to display to the user as a table dialog.
+        Display a simple report of any rule violations in the file to the user as a table dialog.
 
         :param context: The current webhook context or a user object to send requests from.
         :param rule_violations: A dict of rule violations generated by a call to validate_file.
@@ -120,9 +121,24 @@ class FileValidator:
                         "Reason": violation.reason[:2000]
                     })
 
-        callback_util = CallbackUtil(context)
-        callback_util.table_dialog("Errors", "The following rule violations were encountered in the provided file.",
-                                   columns, rows)
+        callback = CallbackUtil(context)
+        callback.table_dialog("Errors", "The following rule violations were encountered in the provided file.",
+                              columns, rows)
+
+    def validate_and_report_errors(self, context: SapioWebhookContext | SapioUser) -> None:
+        """
+        Validate the file. If any rule violations are found, display a simple report of any rule violations in the file
+        to the user as a table dialog and throw a SapioUserCancelled exception after the user acknowledges the dialog
+        to end the webhook interaction.
+
+        Shorthand for calling validate_file() and then build_violation_report() if there are any errors.
+
+        :param context: The current webhook context or a user object to send requests from.
+        """
+        violations = self.validate_file()
+        if violations:
+            self.build_violation_report(context, violations)
+            raise SapioUserCancelledException()
 
 
 class ValidationRule:

sapiopycommons/files/file_writer.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import warnings
 from abc import abstractmethod
 from enum import Enum
 from typing import Any
@@ -18,7 +19,7 @@ class FileWriter:
     body: list[list[Any]]
     delimiter: str
     line_break: str
-    column_definitions: list[ColumnDef]
+    column_definitions: dict[str, ColumnDef]
 
     def __init__(self, headers: list[str], delimiter: str = ",", line_break: str = "\r\n"):
         """
@@ -30,7 +31,7 @@ class FileWriter:
         self.delimiter = delimiter
         self.line_break = line_break
         self.body = []
-        self.column_definitions = []
+        self.column_definitions = {}
 
     def add_row_list(self, row: list[Any]) -> None:
         """
@@ -65,21 +66,49 @@ class FileWriter:
             new_row.append(row.get(header, ""))
         self.body.append(new_row)
 
-    def add_column_definitions(self, column_defs: list[ColumnDef]) -> None:
+    def add_column_definition(self, header: str, column_def: ColumnDef) -> None:
         """
-        Add new column definitions to this FileWriter. Column definitions are evaluated in the order they are added,
-        meaning that they map to the header with the equivalent index. Before the file is built, the number of column
-        definitions must equal the number of headers if any column definition is provided.
+        Add a new column definition to this FileWriter for a specific header.
 
-        ColumnDefs are only used if the build_file function is provided with a list of RowBundles.
+        ColumnDefs are only used if the build_file function is provided with a list of RowBundles. Every header must
+        have a column definition if this is the case.
 
         Custom column definitions can be created by defining a class that extends ColumnDef and implements the print
         method.
 
-        :param column_defs: A list of column definitions to be used to construct the file when build_file is
+        :param column_def: A column definitions to be used to construct the file when build_file is
             called.
+        :param header: The header that this column definition is for. If a header is provided that isn't in the headers
+            list, the header is appended to the end of the list.
         """
-        self.column_definitions.extend(column_defs)
+        if header not in self.headers:
+            self.headers.append(header)
+        self.column_definitions[header] = column_def
+
+    def add_column_definitions(self, column_defs: dict[str, ColumnDef]) -> None:
+        """
+        Add new column definitions to this FileWriter.
+
+        ColumnDefs are only used if the build_file function is provided with a list of RowBundles. Every header must
+        have a column definition if this is the case.
+
+        Custom column definitions can be created by defining a class that extends ColumnDef and implements the print
+        method.
+
+        :param column_defs: A dictionary of header names to column definitions to be used to construct the file when
+            build_file is called.
+        """
+        # For backwards compatibility purposes, if column definitions are provided as a list,
+        # add them in order of appearance of the headers. This will only work if the headers are defined first, though.
+        if isinstance(column_defs, list):
+            warnings.warn("Adding column definitions is no longer expected as a list. Continuing to provide a list to "
+                          "this function may result in undesirable behavior.", UserWarning)
+            if not self.headers:
+                raise SapioException("No headers provided to FileWriter before the column definitions were added.")
+            for header, column_def in zip(self.headers, column_defs):
+                self.column_definitions[header] = column_def
+        for header, column_def in column_defs.items():
+            self.add_column_definition(header, column_def)
 
     def build_file(self, rows: list[RowBundle] | None = None, sorter=None, reverse: bool = False) -> str:
         """
@@ -100,11 +129,10 @@ class FileWriter:
         """
         # If any column definitions have been provided, the number of column definitions and headers must be equal.
         if self.column_definitions:
-            def_count: int = len(self.column_definitions)
-            header_count: int = len(self.headers)
-            if def_count != header_count:
-                raise SapioException(f"FileWriter has {def_count} column definitions defined but {header_count} "
-                                     f"headers. The number of column definitions must equal the number of headers.")
+            for header in self.headers:
+                if header not in self.column_definitions:
+                    raise SapioException(f"FileWriter has no column definition for the header {header}. If any column "
+                                         f"definitions are provided, then all headers must have a column definition.")
         # If any RowBundles have been provided, there must be column definitions for mapping them to the file.
         elif rows:
             raise SapioException(f"FileWriter was given RowBundles but contains no column definitions for mapping "
@@ -130,7 +158,8 @@ class FileWriter:
         rows.sort(key=lambda x: x.index)
         for row in rows:
             new_row: list[Any] = []
-            for column in self.column_definitions:
+            for header in self.headers:
+                column = self.column_definitions[header]
                 if column.may_skip and row.may_skip:
                     new_row.append("")
                 else:

sapiopycommons/general/aliases.py

@@ -2,10 +2,13 @@ from collections.abc import Iterable
 from typing import Any
 
 from sapiopylib.rest.pojo.DataRecord import DataRecord
+from sapiopylib.rest.pojo.datatype.FieldDefinition import FieldType
 from sapiopylib.rest.pojo.eln.ElnExperiment import ElnExperiment
 from sapiopylib.rest.utils.Protocols import ElnExperimentProtocol
 from sapiopylib.rest.utils.recordmodel.PyRecordModel import PyRecordModel
-from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedRecordModel, WrappedType
+from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedRecordModel, WrappedType, WrapperField
+
+from sapiopycommons.general.exceptions import SapioException
 
 RecordModel = PyRecordModel | WrappedRecordModel | WrappedType
 """Different forms that a record model could take."""
@@ -13,6 +16,13 @@ SapioRecord = DataRecord | RecordModel
 """A record could be provided as either a DataRecord, PyRecordModel, or WrappedRecordModel (WrappedType)."""
 RecordIdentifier = SapioRecord | int
 """A RecordIdentifier is either a record type or an integer for the record's record ID."""
+DataTypeIdentifier = SapioRecord | type[WrappedType] | str
+"""A DataTypeIdentifier is either a SapioRecord, a record model wrapper type, or a string."""
+FieldIdentifier = 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."""
+HasFieldWrappers = type[WrappedType] | WrappedRecordModel
+"""An identifier for classes that have wrapper fields."""
 ExperimentIdentifier = ElnExperimentProtocol | ElnExperiment | int
 """An ExperimentIdentifier is either an experiment protocol, experiment, or an integer for te experiment's notebook
 ID."""
@@ -63,14 +73,75 @@ class AliasUtil:
         return record if isinstance(record, int) else record.record_id
 
     @staticmethod
-    def to_data_type_name(record: SapioRecord) -> str:
+    def to_data_type_name(value: DataTypeIdentifier) -> str:
+        """
+        Convert a given value to a data type name.
+
+        :param value: A value which is a string, record, or record model type.
+        :return: A string of the data type name of the input value.
+        """
+        if isinstance(value, str):
+            return value
+        if isinstance(value, SapioRecord):
+            return value.data_type_name
+        return value.get_wrapper_data_type_name()
+
+    @staticmethod
+    def to_data_type_names(values: Iterable[DataTypeIdentifier], return_set: bool = False) -> 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.
+        :return: A list or set of strings of the data type name of the input value.
+        """
+        values = [AliasUtil.to_data_type_name(x) for x in values]
+        return set(values) if return_set else values
+
+    @staticmethod
+    def to_data_field_name(value: FieldIdentifier) -> str:
+        """
+        Convert a string or WrapperField to a data field name string.
+
+        :param value: A string or WrapperField.
+        :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
+        return value
+
+    @staticmethod
+    def to_data_field_names(values: Iterable[FieldIdentifier]) -> list[str]:
+        """
+        Convert an iterable of strings or WrapperFields to a list of data field name strings.
+
+        :param values: An iterable of strings or WrapperFields.
+        :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_field_type(field: FieldIdentifier, data_type: HasFieldWrappers | None = None) -> FieldType:
         """
-        Convert a single variable that could be either a Data Record, PyRecordModel, or WrappedRecordModel to the
-        data type name for that record.
+        Convert a given field identifier to the field type for that field.
 
-        :return: The data type name for the input record.
+        :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.
         """
-        return record.data_type_name
+        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_lists(records: Iterable[SapioRecord]) -> list[FieldMap]: