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

sapiopycommons/callbacks/field_builder.py

@@ -443,6 +443,8 @@ class FieldBuilder:
                 raise SapioException("Unable to set multiple list modes at once for a selection list.")
             # Static values don't have a list mode. Evaluate this last so that the multiple list modes check doesn't
             # need to be more complex.
+            # PR-47531: Even though static values don't use an existing list mode, a list mode must still be set.
+            list_mode = ListMode.USER
 
         if not list_mode and static_values is None:
             raise SapioException("A list mode must be chosen for selection list fields.")

sapiopycommons/chem/Molecules.py

@@ -1,6 +1,5 @@
 # Author Yechen Qiao
 # Common Molecule Utilities for Molecule Transfers with Sapio
-from typing import cast
 
 from rdkit import Chem
 from rdkit.Chem import Crippen, MolToInchi
@@ -9,7 +8,6 @@ from rdkit.Chem import rdMolDescriptors
 from rdkit.Chem.EnumerateStereoisomers import StereoEnumerationOptions, EnumerateStereoisomers
 from rdkit.Chem.MolStandardize import rdMolStandardize
 from rdkit.Chem.SaltRemover import SaltRemover
-from rdkit.Chem.rdChemReactions import ChemicalReaction
 from rdkit.Chem.rdchem import Mol, RWMol, Bond
 
 from sapiopycommons.chem.IndigoMolecules import indigo, renderer, indigo_inchi

sapiopycommons/customreport/auto_pagers.py

@@ -0,0 +1,281 @@
+from abc import ABC
+from copy import copy
+from queue import Queue
+
+from sapiopylib.rest.CustomReportService import CustomReportManager
+from sapiopylib.rest.DataMgmtService import DataMgmtServer
+from sapiopylib.rest.pojo.CustomReport import CustomReportCriteria, CustomReport, RawReportTerm, ReportColumn
+from sapiopylib.rest.pojo.datatype.FieldDefinition import FieldType
+# noinspection PyProtectedMember
+from sapiopylib.rest.utils.autopaging import SapioPyAutoPager, PagerResultCriteriaType, _default_report_page_size, \
+    _default_record_page_size
+from sapiopylib.rest.utils.recordmodel.PyRecordModel import PyRecordModel
+from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedType
+
+from sapiopycommons.general.aliases import FieldValue, UserIdentifier, AliasUtil, RecordModel
+from sapiopycommons.general.custom_report_util import CustomReportUtil
+from sapiopycommons.general.exceptions import SapioException
+from sapiopycommons.recordmodel.record_handler import RecordHandler
+
+
+# FR-47389: Create auto pagers for running custom/system/quick reports that return dictionaries or records for each row.
+class _DictReportPagerBase(SapioPyAutoPager[CustomReportCriteria, dict[str, FieldValue]], ABC):
+    """
+    A base class for automatically paging through a report and returning the results as a list of dictionaries.
+    """
+    _columns: list[ReportColumn]
+    _report_man: CustomReportManager
+
+    def __init__(self, user: UserIdentifier, first_page_criteria: CustomReportCriteria):
+        self._columns = first_page_criteria.column_list
+        super().__init__(AliasUtil.to_sapio_user(user), first_page_criteria)
+        self._report_man = DataMgmtServer.get_custom_report_manager(self.user)
+
+    def get_all_at_once(self) -> list[dict[str, FieldValue]]:
+        """
+        Get the results of all pages. Be cautious of client memory usage.
+        """
+        if self.has_iterated:
+            raise BrokenPipeError("Cannot use this method if the iterator has already been used.")
+        return [x for x in self]
+
+    def default_first_page_criteria(self) -> PagerResultCriteriaType:
+        raise ValueError("Cannot generate a default first page criteria for custom reports.")
+
+    def get_next_page_result(self) -> tuple[CustomReportCriteria | None, Queue[dict[str, FieldValue]]]:
+        report: CustomReport = self._report_man.run_custom_report(self.next_page_criteria)
+        queue: Queue[dict[str, FieldValue]] = Queue()
+        for row in _process_results(report.result_table, self._columns):
+            queue.put(row)
+        if report.has_next_page:
+            next_page_criteria = copy(self.next_page_criteria)
+            next_page_criteria.page_number += 1
+            return next_page_criteria, queue
+        else:
+            return None, queue
+
+
+class CustomReportDictAutoPager(_DictReportPagerBase):
+    """
+    A class that automatically pages through a custom report and returns the results as a list of dictionaries.
+    """
+    def __init__(self, user: UserIdentifier, report_criteria: CustomReportCriteria,
+                 page_number: int = 0, page_size: int = _default_report_page_size):
+        """
+        :param user: The current webhook context or a user object to send requests from.
+        :param report_criteria: The custom report criteria to run.
+        :param page_number: The page number to start on. The first page is page 0.
+        :param page_size: The number of results to return per page.
+        """
+        first_page_criteria: CustomReportCriteria = copy(report_criteria)
+        first_page_criteria.page_number = page_number
+        first_page_criteria.page_size = page_size
+        super().__init__(user, first_page_criteria)
+
+
+class SystemReportDictAutoPager(_DictReportPagerBase):
+    """
+    A class that automatically pages through a system report and returns the results as a list of dictionaries.
+
+    System reports are also known as predefined searches in the system and must be defined in the data designer for
+    a specific data type. That is, saved searches created by users cannot be run using this function.
+    """
+    def __init__(self, user: UserIdentifier, report_name: str,
+                 page_number: int = 0, page_size: int = _default_report_page_size):
+        """
+        :param user: The current webhook context or a user object to send requests from.
+        :param report_name: The name of the system report to run.
+        :param page_number: The page number to start on. The first page is page 0.
+        :param page_size: The number of results to return per page.
+        """
+        first_page_criteria: CustomReportCriteria = CustomReportUtil.get_system_report_criteria(user, report_name)
+        first_page_criteria.page_number = page_number
+        first_page_criteria.page_size = page_size
+        super().__init__(user, first_page_criteria)
+
+
+class QuickReportDictAutoPager(_DictReportPagerBase):
+    """
+    A class that automatically pages through a quick report and returns the results as a list of dictionaries.
+    """
+    def __init__(self, user: UserIdentifier, report_term: RawReportTerm,
+                 page_number: int = 0, page_size: int = _default_report_page_size):
+        """
+        :param user: The current webhook context or a user object to send requests from.
+        :param report_term: The raw report term to use for the quick report.
+        :param page_number: The page number to start on. The first page is page 0.
+        :param page_size: The number of results to return per page.
+        """
+        first_page_criteria: CustomReportCriteria = CustomReportUtil.get_quick_report_criteria(user, report_term)
+        first_page_criteria.page_number = page_number
+        first_page_criteria.page_size = page_size
+        super().__init__(user, first_page_criteria)
+
+
+# CR-47491: Support providing a data type name string to receive PyRecordModels instead of requiring a WrapperType.
+class _RecordReportPagerBase(SapioPyAutoPager[CustomReportCriteria, WrappedType | PyRecordModel], ABC):
+    """
+    A base class for automatically paging through a report and returning the results as a list of records.
+    """
+    _columns: list[ReportColumn]
+    _query_type: type[WrappedType] | str
+    _data_type: str
+    _rec_handler: RecordHandler
+    _report_man: CustomReportManager
+
+    def __init__(self, user: UserIdentifier, first_page_criteria: CustomReportCriteria,
+                 wrapper_type: type[WrappedType] | str):
+        self._columns = first_page_criteria.column_list
+        self._query_type = wrapper_type
+        self._data_type = AliasUtil.to_data_type_name(wrapper_type)
+        self._rec_handler = RecordHandler(user)
+        super().__init__(AliasUtil.to_sapio_user(user), first_page_criteria)
+        self._report_man = DataMgmtServer.get_custom_report_manager(self.user)
+
+    def get_all_at_once(self) -> list[RecordModel]:
+        """
+        Get the results of all pages. Be cautious of client memory usage.
+        """
+        if self.has_iterated:
+            raise BrokenPipeError("Cannot use this method if the iterator has already been used.")
+        return [x for x in self]
+
+    def default_first_page_criteria(self) -> PagerResultCriteriaType:
+        raise ValueError("Cannot generate a default first page criteria for custom reports.")
+
+    def get_next_page_result(self) -> tuple[CustomReportCriteria | None, Queue[WrappedType] | Queue[PyRecordModel]]:
+        report: CustomReport = self._report_man.run_custom_report(self.next_page_criteria)
+        queue = Queue()
+        id_index: int = -1
+        for i, column in enumerate(self._columns):
+            if column.data_type_name == self._data_type and column.data_field_name == "RecordId":
+                id_index = i
+                break
+        if id_index == -1:
+            raise SapioException(f"This report does not contain a Record ID column for the given record model type "
+                                 f"{self._data_type}.")
+        ids: set[int] = {row[id_index] for row in report.result_table}
+        for row in self._rec_handler.query_models_by_id(self._query_type, ids, page_size=report.page_size):
+            queue.put(row)
+        if report.has_next_page:
+            next_page_criteria = copy(self.next_page_criteria)
+            next_page_criteria.page_number += 1
+            return next_page_criteria, queue
+        else:
+            return None, queue
+
+
+class CustomReportRecordAutoPager(_RecordReportPagerBase):
+    """
+    A class that automatically pages through a custom report and returns the results as a list of records.
+    """
+    def __init__(self, user: UserIdentifier, report_criteria: CustomReportCriteria,
+                 wrapper_type: type[WrappedType] | str, page_number: int = 0,
+                 page_size: int = _default_record_page_size):
+        """
+        :param user: The current webhook context or a user object to send requests from.
+        :param report_criteria: The custom report criteria to run.
+        :param wrapper_type: The record model wrapper type or data type name of the records being searched for.
+            If a data type name was used instead of a model wrapper, then the returned records will be PyRecordModels
+            instead of WrappedRecordModels.
+        :param page_number: The page number to start on. The first page is page 0.
+        :param page_size: The number of results to return per page.
+        """
+        first_page_criteria: CustomReportCriteria = copy(report_criteria)
+        _add_record_id_column(first_page_criteria, wrapper_type)
+        first_page_criteria.page_number = page_number
+        first_page_criteria.page_size = page_size
+        super().__init__(user, first_page_criteria, wrapper_type)
+
+
+class SystemReportRecordAutoPager(_RecordReportPagerBase):
+    """
+    A class that automatically pages through a system report and returns the results as a list of records.
+
+    System reports are also known as predefined searches in the system and must be defined in the data designer for
+    a specific data type. That is, saved searches created by users cannot be run using this function.
+    """
+    def __init__(self, user: UserIdentifier, report_name: str, wrapper_type: type[WrappedType] | str,
+                 page_number: int = 0, page_size: int = _default_record_page_size):
+        """
+        :param user: The current webhook context or a user object to send requests from.
+        :param report_name: The name of the system report to run.
+        :param wrapper_type: The record model wrapper type or data type name of the records being searched for.
+            If a data type name was used instead of a model wrapper, then the returned records will be PyRecordModels
+            instead of WrappedRecordModels.
+        :param page_number: The page number to start on. The first page is page 0.
+        :param page_size: The number of results to return per page.
+        """
+        first_page_criteria: CustomReportCriteria = CustomReportUtil.get_system_report_criteria(user, report_name)
+        _add_record_id_column(first_page_criteria, wrapper_type)
+        first_page_criteria.page_number = page_number
+        first_page_criteria.page_size = page_size
+        super().__init__(user, first_page_criteria, wrapper_type)
+
+
+class QuickReportRecordAutoPager(_RecordReportPagerBase):
+    """
+    A class that automatically pages through a quick report and returns the results as a list of records.
+    """
+    def __init__(self, user: UserIdentifier, report_term: RawReportTerm, wrapper_type: type[WrappedType] | str,
+                 page_number: int = 0, page_size: int = _default_record_page_size):
+        """
+        :param user: The current webhook context or a user object to send requests from.
+        :param report_term: The raw report term to use for the quick report.
+        :param wrapper_type: The record model wrapper type or data type name of the records being searched for.
+            If a data type name was used instead of a model wrapper, then the returned records will be PyRecordModels
+            instead of WrappedRecordModels.
+        :param page_number: The page number to start on. The first page is page 0.
+        :param page_size: The number of results to return per page.
+        """
+        if report_term.data_type_name != AliasUtil.to_data_type_name(wrapper_type):
+            raise SapioException("The data type name of the report term must match the data type name of the wrapper type.")
+        first_page_criteria: CustomReportCriteria = CustomReportUtil.get_quick_report_criteria(user, report_term)
+        first_page_criteria.page_number = page_number
+        first_page_criteria.page_size = page_size
+        super().__init__(user, first_page_criteria, wrapper_type)
+
+
+def _add_record_id_column(report: CustomReportCriteria, wrapper_type: type[WrappedType] | str) -> None:
+    """
+    Given a custom report criteria, ensure that the report contains a Record ID column for the given record model's
+    data type. Add one if it is missing.
+    """
+    dt: str = AliasUtil.to_data_type_name(wrapper_type)
+    # Ensure that the root data type is the one we're looking for.
+    report.root_data_type = dt
+    # Enforce that the given custom report has a record ID column.
+    if not any([x.data_type_name == dt and x.data_field_name == "RecordId" for x in report.column_list]):
+        report.column_list.append(ReportColumn(dt, "RecordId", FieldType.LONG))
+
+
+def _process_results(rows: list[list[FieldValue]], columns: list[ReportColumn]) -> list[dict[str, FieldValue]]:
+    """
+    Given the results of a report as a list of row values and the report's columns, combine these lists to
+    result in a singular list of dictionaries for each row in the results.
+    """
+    # It may be the case that two columns have the same data field name but differing data type names.
+    # If this occurs, then we need to be able to differentiate these columns in the resulting dictionary.
+    prepend_dt: set[str] = set()
+    encountered_names: list[str] = []
+    for column in columns:
+        field_name: str = column.data_field_name
+        if field_name in encountered_names:
+            prepend_dt.add(field_name)
+        else:
+            encountered_names.append(field_name)
+
+    ret: list[dict[str, FieldValue]] = []
+    for row in rows:
+        row_data: dict[str, FieldValue] = {}
+        filter_row: bool = False
+        for value, column in zip(row, columns):
+            header: str = column.data_field_name
+            # If two columns share the same data field name, prepend the data type name of the column to the
+            # data field name.
+            if header in prepend_dt:
+                header = column.data_type_name + "." + header
+            row_data.update({header: value})
+        if filter_row is False:
+            ret.append(row_data)
+    return ret

sapiopycommons/customreport/term_builder.py

@@ -279,7 +279,7 @@ class TermBuilder:
 
         :param a: The first term in the operation.
         :param b: The second term in the operation.
-        :param is_negated: Whether the returned term should be negated (i.e. turn this into an xnor operation).
+        :param is_negated: Whether the returned term should be negated (i.e. turn this into an XNOR operation).
         :return: A composite report term for "A xor B".
         """
         return TermBuilder.and_terms(TermBuilder.or_terms(a, b),

sapiopycommons/datatype/attachment_util.py

@@ -1,6 +1,7 @@
 import io
 
 from sapiopylib.rest.DataMgmtService import DataMgmtServer
+from sapiopylib.rest.utils.recordmodel.PyRecordModel import PyRecordModel
 from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedType
 
 from sapiopycommons.general.aliases import AliasUtil, SapioRecord, UserIdentifier
@@ -49,9 +50,10 @@ class AttachmentUtil:
         with io.BytesIO(file_bytes) as stream:
             dr_man.set_attachment_data(attachment, file_name, stream)
 
+    # CR-47491: Support providing a data type name string to receive PyRecordModels instead of requiring a WrapperType.
     @staticmethod
     def create_attachment(context: UserIdentifier, file_name: str, file_bytes: bytes,
-                          wrapper_type: type[WrappedType]) -> WrappedType:
+                          wrapper_type: type[WrappedType] | str) -> WrappedType | PyRecordModel:
         """
         Create an attachment data type and initialize its attachment bytes at the same time.
         Makes a webservice call to create the attachment record and a second to set its bytes.
@@ -62,6 +64,6 @@ class AttachmentUtil:
         :param wrapper_type: The attachment type to create.
         :return: A record model for the newly created attachment.
         """
-        attachment: WrappedType = RecordHandler(context).create_models(wrapper_type, 1)[0]
+        attachment: WrappedType | PyRecordModel = RecordHandler(context).create_models(wrapper_type, 1)[0]
         AttachmentUtil.set_attachment_bytes(context, attachment, file_name, file_bytes)
         return attachment

sapiopycommons/datatype/data_fields.py

@@ -58,4 +58,26 @@ class ProcessWorkflowTrackingFields:
     WORKFLOW_PROCESS_TAT__FIELD = WrapperField("WorkflowProcessTAT", FieldType.DOUBLE)
     WORKFLOW_START_USER_ID__FIELD = WrapperField("WorkflowStartUserId", FieldType.STRING)
     WORKFLOW_TAT__FIELD = WrapperField("WorkflowTAT", FieldType.DOUBLE)
-    WORKFLOW_VERSION__FIELD = WrapperField("WorkflowVersion", FieldType.LONG)
+    WORKFLOW_VERSION__FIELD = WrapperField("WorkflowVersion", FieldType.LONG)
+
+class PlateDesignerWellElementFields:
+    DATA_TYPE_NAME = 'PlateDesignerWellElement'
+    ACTUAL_VOLUME_REMOVED__FIELD = WrapperField("ActualVolumeRemoved", FieldType.DOUBLE)
+    ALIQUOT_SAMPLE_RECORD_ID__FIELD = WrapperField("AliquotSampleRecordId", FieldType.LONG)
+    COL_POSITION__FIELD = WrapperField("ColPosition", FieldType.SELECTION)
+    CONCENTRATION__FIELD = WrapperField("Concentration", FieldType.DOUBLE)
+    CONCENTRATION_UNITS__FIELD = WrapperField("ConcentrationUnits", FieldType.STRING)
+    CONTROL_TYPE__FIELD = WrapperField("ControlType", FieldType.STRING)
+    DILUTION_SCHEME__FIELD = WrapperField("DilutionScheme", FieldType.DOUBLE)
+    IS_CONTROL__FIELD = WrapperField("IsControl", FieldType.BOOLEAN)
+    LAYER__FIELD = WrapperField("Layer", FieldType.INTEGER)
+    PLATE_RECORD_ID__FIELD = WrapperField("PlateRecordId", FieldType.LONG)
+    ROW_POSITION__FIELD = WrapperField("RowPosition", FieldType.SELECTION)
+    SOURCE_DATA_TYPE_NAME__FIELD = WrapperField("SourceDataTypeName", FieldType.STRING)
+    SOURCE_RECORD_ID__FIELD = WrapperField("SourceRecordId", FieldType.LONG)
+    SOURCE_SAMPLE_CONCENTRATION__FIELD = WrapperField("SourceSampleConcentration", FieldType.DOUBLE)
+    SOURCE_SAMPLE_MASS__FIELD = WrapperField("SourceSampleMass", FieldType.DOUBLE)
+    SOURCE_SAMPLE_VOLUME__FIELD = WrapperField("SourceSampleVolume", FieldType.DOUBLE)
+    SOURCE_VOLUME_TO_REMOVE__FIELD = WrapperField("SourceVolumeToRemove", FieldType.DOUBLE)
+    TARGET_MASS__FIELD = WrapperField("TargetMass", FieldType.DOUBLE)
+    VOLUME__FIELD = WrapperField("Volume", FieldType.DOUBLE)

sapiopycommons/eln/experiment_cache.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+from weakref import WeakValueDictionary
+
+from sapiopylib.rest.ELNService import ElnManager
+from sapiopylib.rest.User import SapioUser
+from sapiopylib.rest.pojo.datatype.FieldDefinition import AbstractVeloxFieldDefinition
+from sapiopylib.rest.pojo.eln.ElnExperiment import ElnTemplate, TemplateExperimentQuery
+from sapiopylib.rest.pojo.eln.SapioELNEnums import ElnBaseDataType
+from sapiopylib.rest.pojo.eln.field_set import ElnFieldSetInfo
+from sapiopylib.rest.pojo.eln.protocol_template import ProtocolTemplateInfo, ProtocolTemplateQuery
+
+from sapiopycommons.general.aliases import UserIdentifier, AliasUtil
+from sapiopycommons.general.exceptions import SapioException
+
+
+# FR-47530: Created a class that caches experiment template and predefined field information.
+class ExperimentCacheManager:
+    """
+    A class to manage the caching of experiment-related information.
+    """
+    user: SapioUser
+    eln_man: ElnManager
+
+    _templates: list[ElnTemplate]
+    """A list of experiment templates. Only cached when first accessed."""
+    _protocols: list[ProtocolTemplateInfo]
+    """A list of protocol templates. Only cached when first accessed."""
+    _field_sets: dict[str, ElnFieldSetInfo]
+    """A dictionary of field set name to field set. Only cached when first accessed."""
+    _field_set_fields: dict[int, list[AbstractVeloxFieldDefinition]]
+    """A dictionary of field set ID to field definitions. Only cached when first accessed."""
+    _predefined_fields: dict[str, dict[str, AbstractVeloxFieldDefinition]]
+    """A dictionary of ELN data type name to predefined field definitions. Only cached when first accessed."""
+
+    __instances: WeakValueDictionary[SapioUser, ExperimentCacheManager] = WeakValueDictionary()
+    __initialized: bool
+
+    def __new__(cls, context: UserIdentifier):
+        """
+        :param context: The current webhook context or a user object to send requests from.
+        """
+        user = AliasUtil.to_sapio_user(context)
+        obj = cls.__instances.get(user)
+        if not obj:
+            obj = object.__new__(cls)
+            obj.__initialized = False
+            cls.__instances[user] = obj
+        return obj
+
+    def __init__(self, context: UserIdentifier):
+        """
+        :param context: The current webhook context or a user object to send requests from.
+        """
+        if self.__initialized:
+            return
+        self.__initialized = True
+
+        self.user = AliasUtil.to_sapio_user(context)
+        self.eln_man = ElnManager(self.user)
+
+        self._field_set_fields = {}
+        self._predefined_fields = {}
+
+    def get_experiment_template(self, name: str, active: bool = True, version: int | None = None,
+                                first_match: bool = False) -> ElnTemplate:
+        """
+        Get the experiment template with the given information.
+
+        :param name: The name of the template.
+        :param active: Whether the template is marked as active.
+        :param version: The version of the template to get. If None, the latest version will be returned.
+        :param first_match: If true, returns the first match found. If false, raises an exception.
+        :return: The experiment template with the given information.
+        """
+        if not hasattr(self, "_templates"):
+            query = TemplateExperimentQuery()
+            query.active_templates_only = False
+            query.latest_version_only = False
+            self._templates = self.eln_man.get_template_experiment_list(query)
+        return self._find_template(self._templates, name, active, version, first_match)
+
+
+    def get_protocol_template(self, name: str, active: bool = True, version: int | None = None,
+                              first_match: bool = False) -> ProtocolTemplateInfo:
+        """
+        Get the protocol template with the given information. Will throw an exception if multiple templates match
+        the given information.
+
+        :param name: The name of the template.
+        :param active: Whether the template is marked as active.
+        :param version: The version of the template to get. If None, the latest version will be returned.
+        :param first_match: If true, returns the first match found. If false, raises an exception.
+        :return: The protocol template with the given information.
+        """
+        if not hasattr(self, "_protocols"):
+            query = ProtocolTemplateQuery()
+            query.active_templates_only = False
+            query.latest_version_only = False
+            self._protocols = self.eln_man.get_protocol_template_info_list(query)
+        return self._find_template(self._protocols, name, active, version, first_match)
+
+    @staticmethod
+    def _find_template(templates: list[ElnTemplate] | list[ProtocolTemplateInfo], name: str, active: bool,
+                       version: int, first_match: bool) -> ElnTemplate | ProtocolTemplateInfo:
+        """
+        Find the experiment or protocol template with the given information.
+        """
+        matches = []
+        for template in templates:
+            if template.template_name != name:
+                continue
+            if template.active != active:
+                continue
+            if version is not None and template.template_version != version:
+                continue
+            matches.append(template)
+        if not matches:
+            raise SapioException(f"No template with the name \"{name}\"" +
+                                 ("" if version is None else f" and the version {version}") +
+                                 f" found.")
+        if not version:
+            return max(matches, key=lambda x: x.template_version)
+        if len(matches) > 1 and not first_match:
+            raise SapioException(f"Multiple templates with the name \"{name}\" found.")
+        return matches[0]
+
+    def get_predefined_field(self, field_name: str, data_type: ElnBaseDataType) -> AbstractVeloxFieldDefinition:
+        """
+        Get the predefined field of the given name for the given ELN data type.
+
+        :param field_name: The name of the field.
+        :param data_type: The ELN data type of the field.
+        :return: The predefined field of the given name for the given ELN data type.
+        """
+        return self.get_predefined_fields(data_type)[field_name]
+
+    def get_predefined_fields(self, data_type: ElnBaseDataType) -> dict[str, AbstractVeloxFieldDefinition]:
+        """
+        Get the predefined fields for the given ELN data type.
+
+        :param data_type: The ELN data type to get the predefined fields for.
+        :return: A dictionary of field name to field definition for the given ELN data type.
+        """
+        if data_type.data_type_name not in self._predefined_fields:
+            fields: list[AbstractVeloxFieldDefinition] = self.eln_man.get_predefined_fields(data_type)
+            self._predefined_fields[data_type.data_type_name] = {x.data_field_name: x for x in fields}
+        return self._predefined_fields[data_type.data_type_name]
+
+    def get_field_set(self, name: str) -> ElnFieldSetInfo:
+        """
+        Get the field set with the given name.
+
+        :param name: The name of the field set.
+        :return: The field set with the given name.
+        """
+        if not hasattr(self, "_field_sets"):
+            self._field_sets = {x.field_set_name: x for x in self.eln_man.get_field_set_info_list()}
+        return self._field_sets[name]
+
+    def get_field_set_fields(self, field_set: ElnFieldSetInfo | int) -> list[AbstractVeloxFieldDefinition]:
+        """
+        Get the fields of the given field set.
+
+        :param field_set: The field set to get the fields from. Can be either an ElnFieldSetInfo object or an integer
+            for the set ID.
+        :return: The fields of the given field set.
+        """
+        field_set: int = field_set if isinstance(field_set, int) else field_set.field_set_id
+        if field_set in self._field_set_fields:
+            return self._field_set_fields[field_set]
+        self._field_set_fields[field_set] = self.eln_man.get_predefined_fields_from_field_set_id(field_set)
+        return self._field_set_fields[field_set]