sapiopycommons 2025.3.27a461__py3-none-any.whl → 2025.4.3a467__py3-none-any.whl

sapiopycommons/callbacks/callback_util.py

@@ -4,7 +4,7 @@ import io
 import re
 import warnings
 from copy import copy
-from typing import Iterable, TypeAlias, Any, Callable
+from typing import Iterable, TypeAlias, Any, Callable, Container, Collection
 from weakref import WeakValueDictionary
 
 from requests import ReadTimeout
@@ -43,6 +43,12 @@ from sapiopycommons.recordmodel.record_handler import RecordHandler
 DataTypeLayoutIdentifier: TypeAlias = DataTypeLayout | str | None
 
 
+# CR-47521: Updated various parameter type hints from list or Iterable to more specific type hints.
+# If we need to iterate over the parameter, then it is Iterable.
+# If we need to see if the parameter contains a value, then it is Container.
+# If the length/size of the parameter is needed, then it is Collection.
+# If we need to access the parameter by an index, then it is Sequence. (This excludes sets and dictionaries, so it's
+# probably better to accept a Collection then cast the parameter to a list if you need to get an element from it.)
 class CallbackUtil:
     user: SapioUser
     callback: ClientCallback
@@ -193,7 +199,7 @@ class CallbackUtil:
     def ok_cancel_dialog(self, title: str, msg: str, default_ok: bool = True) -> bool:
         """
         Create an option dialog where the only options are "OK" and "Cancel". Doesn't allow the user to cancel the
-        dialog using the X at the top right corner.
+        dialog using the X in the top right corner.
 
         :param title: The title of the dialog.
         :param msg: The message to display in the dialog. This can be formatted using HTML elements.
@@ -205,7 +211,7 @@ class CallbackUtil:
     def yes_no_dialog(self, title: str, msg: str, default_yes: bool = True) -> bool:
         """
         Create an option dialog where the only options are "Yes" and "No". Doesn't allow the user to cancel the
-        dialog using the X at the top right corner.
+        dialog using the X in the top right corner.
 
         :param title: The title of the dialog.
         :param msg: The message to display in the dialog. This can be formatted using HTML elements.
@@ -258,7 +264,7 @@ class CallbackUtil:
     def form_dialog(self,
                     title: str,
                     msg: str,
-                    fields: list[AbstractVeloxFieldDefinition],
+                    fields: Iterable[AbstractVeloxFieldDefinition],
                     values: FieldMap = None,
                     column_positions: dict[str, tuple[int, int]] = None,
                     *,
@@ -296,7 +302,7 @@ class CallbackUtil:
     def record_form_dialog(self,
                            title: str,
                            msg: str,
-                           fields: list[FieldIdentifier | FieldFilterCriteria] | DataTypeLayoutIdentifier,
+                           fields: Iterable[FieldIdentifier | FieldFilterCriteria] | DataTypeLayoutIdentifier,
                            record: SapioRecord,
                            column_positions: dict[str, tuple[int, int]] | None = None,
                            editable=None,
@@ -369,7 +375,7 @@ class CallbackUtil:
     def set_record_form_dialog(self,
                                title: str,
                                msg: str,
-                               fields: list[FieldIdentifier | FieldFilterCriteria] | DataTypeLayoutIdentifier,
+                               fields: Iterable[FieldIdentifier | FieldFilterCriteria] | DataTypeLayoutIdentifier,
                                record: SapioRecord,
                                column_positions: dict[str, tuple[int, int]] | None = None,
                                *,
@@ -412,7 +418,7 @@ class CallbackUtil:
     def create_record_form_dialog(self,
                                   title: str,
                                   msg: str,
-                                  fields: list[FieldIdentifier | FieldFilterCriteria] | DataTypeLayoutIdentifier,
+                                  fields: Iterable[FieldIdentifier | FieldFilterCriteria] | DataTypeLayoutIdentifier,
                                   wrapper_type: type[WrappedType] | str,
                                   column_positions: dict[str, tuple[int, int]] | None = None,
                                   *,
@@ -618,14 +624,14 @@ class CallbackUtil:
     def table_dialog(self,
                      title: str,
                      msg: str,
-                     fields: list[AbstractVeloxFieldDefinition],
-                     values: list[FieldMap],
+                     fields: Iterable[AbstractVeloxFieldDefinition],
+                     values: Iterable[FieldMap],
                      *,
                      data_type: DataTypeIdentifier = "Default",
                      display_name: str | None = None,
                      plural_display_name: str | None = None,
                      group_by: FieldIdentifier | None = None,
-                     image_data: list[bytes] | None = None) -> list[FieldMap]:
+                     image_data: Iterable[bytes] | None = None) -> list[FieldMap]:
         """
         Create a table dialog where the user may input data into the fields of the table. Requires that the caller
         provide the definitions of every field in the table.
@@ -660,7 +666,7 @@ class CallbackUtil:
         temp_dt.record_image_assignable = bool(image_data)
 
         # Send the request to the user.
-        request = TableEntryDialogRequest(title, msg, temp_dt, values,
+        request = TableEntryDialogRequest(title, msg, temp_dt, list(values),
                                           record_image_data_list=image_data, group_by_field=group_by,
                                           width_in_pixels=self.width_pixels, width_percentage=self.width_percent)
         response: list[FieldMap] = self.__handle_dialog_request(request, self.callback.show_table_entry_dialog)
@@ -669,14 +675,14 @@ class CallbackUtil:
     def record_table_dialog(self,
                             title: str,
                             msg: str,
-                            fields: list[FieldIdentifier | FieldFilterCriteria] | DataTypeLayoutIdentifier,
-                            records: list[SapioRecord],
+                            fields: Iterable[FieldIdentifier | FieldFilterCriteria] | DataTypeLayoutIdentifier,
+                            records: Iterable[SapioRecord],
                             editable=None,
                             *,
                             default_modifier: FieldModifier | None = None,
                             field_modifiers: dict[FieldIdentifier, FieldModifier] | None = None,
                             group_by: FieldIdentifier | None = None,
-                            image_data: list[bytes] | None = None) -> list[FieldMap]:
+                            image_data: Iterable[bytes] | None = None) -> list[FieldMap]:
         """
         Create a table dialog where the user may input data into the fields of the table. The table is constructed from
         a given list of records of a singular type.
@@ -750,13 +756,13 @@ class CallbackUtil:
     def set_record_table_dialog(self,
                                 title: str,
                                 msg: str,
-                                fields: list[FieldValue] | DataTypeLayoutIdentifier,
-                                records: list[SapioRecord],
+                                fields: Iterable[FieldValue] | DataTypeLayoutIdentifier,
+                                records: Iterable[SapioRecord],
                                 *,
                                 default_modifier: FieldModifier | None = None,
                                 field_modifiers: dict[FieldIdentifier, FieldModifier] | None = None,
                                 group_by: FieldIdentifier | None = None,
-                                image_data: list[bytes] | None = None):
+                                image_data: Iterable[bytes] | None = None):
         """
         Create a table dialog where the user may input data into the fields of the table. The table is constructed from
         a given list of records of a singular type. After the user submits this dialog, the values that the user
@@ -798,14 +804,14 @@ class CallbackUtil:
     def create_record_table_dialog(self,
                                    title: str,
                                    msg: str,
-                                   fields: list[FieldValue] | DataTypeLayoutIdentifier,
+                                   fields: Iterable[FieldValue] | DataTypeLayoutIdentifier,
                                    wrapper_type: type[WrappedType] | str,
                                    count: int | tuple[int, int],
                                    *,
                                    default_modifier: FieldModifier | None = None,
                                    field_modifiers: dict[FieldIdentifier, FieldModifier] | None = None,
                                    group_by: FieldIdentifier | None = None,
-                                   image_data: list[bytes] | None = None,
+                                   image_data: Iterable[bytes] | None = None,
                                    require_input: bool = False,
                                    repeat_message: str | None = "Please provide a value to continue.") \
             -> list[WrappedType] | list[PyRecordModel]:
@@ -860,14 +866,14 @@ class CallbackUtil:
     def record_adaptive_dialog(self,
                                title: str,
                                msg: str,
-                               fields: list[FieldIdentifier | FieldFilterCriteria] | DataTypeLayoutIdentifier,
-                               records: list[SapioRecord],
+                               fields: Iterable[FieldIdentifier | FieldFilterCriteria] | DataTypeLayoutIdentifier,
+                               records: Collection[SapioRecord],
                                *,
                                default_modifier: FieldModifier | None = None,
                                field_modifiers: dict[FieldIdentifier, FieldModifier] | None = None,
                                column_positions: dict[str, tuple[int, int]] | None = None,
                                group_by: FieldIdentifier | None = None,
-                               image_data: list[bytes] | None = None) -> list[FieldMap]:
+                               image_data: Iterable[bytes] | None = None) -> list[FieldMap]:
         """
         Create a dialog where the user may input data into the specified fields. The dialog is constructed from
         a given list of records of a singular type.
@@ -911,7 +917,7 @@ class CallbackUtil:
         if not count:
             raise SapioException("No records provided.")
         if count == 1:
-            return [self.record_form_dialog(title, msg, fields, records[0], column_positions,
+            return [self.record_form_dialog(title, msg, fields, list(records)[0], column_positions,
                                             default_modifier=default_modifier, field_modifiers=field_modifiers)]
         return self.record_table_dialog(title, msg, fields, records,
                                         default_modifier=default_modifier, field_modifiers=field_modifiers,
@@ -920,14 +926,14 @@ class CallbackUtil:
     def set_record_adaptive_dialog(self,
                                    title: str,
                                    msg: str,
-                                   fields: list[FieldIdentifier | FieldFilterCriteria] | DataTypeLayoutIdentifier,
-                                   records: list[SapioRecord],
+                                   fields: Iterable[FieldIdentifier | FieldFilterCriteria] | DataTypeLayoutIdentifier,
+                                   records: Collection[SapioRecord],
                                    *,
                                    default_modifier: FieldModifier | None = None,
                                    field_modifiers: dict[FieldIdentifier, FieldModifier] | None = None,
                                    column_positions: dict[str, tuple[int, int]] | None = None,
                                    group_by: FieldIdentifier | None = None,
-                                   image_data: list[bytes] | None = None) -> None:
+                                   image_data: Iterable[bytes] | None = None) -> None:
         """
         Create a dialog where the user may input data into the fields of the dialog. The dialog is constructed from
         a given list of records of a singular type. After the user submits this dialog, the values that the user
@@ -969,7 +975,7 @@ class CallbackUtil:
         if not count:
             raise SapioException("No records provided.")
         if count == 1:
-            self.set_record_form_dialog(title, msg, fields, records[0], column_positions,
+            self.set_record_form_dialog(title, msg, fields, list(records)[0], column_positions,
                                         default_modifier=default_modifier, field_modifiers=field_modifiers)
         else:
             self.set_record_table_dialog(title, msg, fields, records,
@@ -979,7 +985,7 @@ class CallbackUtil:
     def create_record_adaptive_dialog(self,
                                       title: str,
                                       msg: str,
-                                      fields: list[FieldValue] | DataTypeLayoutIdentifier,
+                                      fields: Iterable[FieldValue] | DataTypeLayoutIdentifier,
                                       wrapper_type: type[WrappedType] | str,
                                       count: int | tuple[int, int],
                                       *,
@@ -987,7 +993,7 @@ class CallbackUtil:
                                       field_modifiers: dict[FieldIdentifier, FieldModifier] | None = None,
                                       column_positions: dict[str, tuple[int, int]] | None = None,
                                       group_by: FieldIdentifier | None = None,
-                                      image_data: list[bytes] | None = None,
+                                      image_data: Iterable[bytes] | None = None,
                                       require_input: bool = False,
                                       repeat_message: str | None = "Please provide a value to continue.") \
             -> list[WrappedType]:
@@ -1050,8 +1056,8 @@ class CallbackUtil:
     def multi_type_table_dialog(self,
                                 title: str,
                                 msg: str,
-                                fields: list[tuple[DataTypeIdentifier, FieldIdentifier] | AbstractVeloxFieldDefinition],
-                                row_contents: list[list[SapioRecord | FieldMap]],
+                                fields: Iterable[tuple[DataTypeIdentifier, FieldIdentifier] | AbstractVeloxFieldDefinition],
+                                row_contents: Iterable[Iterable[SapioRecord | FieldMap]],
                                 *,
                                 default_modifier: FieldModifier | None = None,
                                 field_modifiers: dict[FieldIdentifier, FieldModifier] | None = None,
@@ -1226,7 +1232,7 @@ class CallbackUtil:
                            layout: DataTypeLayoutIdentifier = None,
                            minimized: bool = False,
                            access_level: FormAccessLevel | None = None,
-                           plugin_path_list: list[str] | None = None) -> None:
+                           plugin_path_list: Iterable[str] | None = None) -> None:
         """
         Create an IDV dialog for the given record. This IDV may use an existing layout already defined in the system,
         and can be created to allow the user to edit the field in the IDV, or to be read-only for the user to review.
@@ -1263,15 +1269,15 @@ class CallbackUtil:
     # CR-47326: Allow the selection dialog functions to preselect rows/records in the table.
     def selection_dialog(self,
                          msg: str,
-                         fields: list[AbstractVeloxFieldDefinition],
-                         values: list[FieldMap],
+                         fields: Iterable[AbstractVeloxFieldDefinition],
+                         values: Iterable[FieldMap],
                          multi_select: bool = True,
-                         preselected_rows: list[FieldMap | RecordIdentifier] | None = None,
+                         preselected_rows: Iterable[FieldMap | RecordIdentifier] | None = None,
                          *,
                          data_type: DataTypeIdentifier = "Default",
                          display_name: str | None = None,
                          plural_display_name: str | None = None,
-                         image_data: list[bytes] | None = None,
+                         image_data: Iterable[bytes] | None = None,
                          require_selection: bool = False,
                          repeat_message: str | None = "Please provide a selection to continue.") -> list[FieldMap]:
         """
@@ -1329,6 +1335,7 @@ class CallbackUtil:
 
             # Add a RecordId definition to the fields if one is not already present. This is necessary for the
             # pre-selected records parameter to function.
+            fields = list(fields)
             if "RecordId" not in [x.data_field_name for x in fields]:
                 builder = FieldBuilder(data_type)
                 fields.append(builder.long_field("RecordId", abstract_info=AnyFieldInfo(visible=False)))
@@ -1338,7 +1345,7 @@ class CallbackUtil:
         temp_dt.record_image_assignable = bool(image_data)
 
         # Send the request to the user.
-        request = TempTableSelectionRequest(temp_dt, msg, values, image_data, preselected_rows, multi_select)
+        request = TempTableSelectionRequest(temp_dt, msg, list(values), image_data, preselected_rows, multi_select)
         # If require_selection is true, repeat the request if the user didn't make a selection.
         while True:
             response: list[FieldMap] = self.__handle_dialog_request(request,
@@ -1351,12 +1358,12 @@ class CallbackUtil:
 
     def record_selection_dialog(self,
                                 msg: str,
-                                fields: list[FieldIdentifier | FieldFilterCriteria] | DataTypeLayoutIdentifier,
-                                records: list[SapioRecord],
+                                fields: Iterable[FieldIdentifier | FieldFilterCriteria] | DataTypeLayoutIdentifier,
+                                records: Iterable[SapioRecord],
                                 multi_select: bool = True,
-                                preselected_records: list[RecordIdentifier] | None = None,
+                                preselected_records: Iterable[RecordIdentifier] | None = None,
                                 *,
-                                image_data: list[bytes] | None = None,
+                                image_data: Iterable[bytes] | None = None,
                                 require_selection: bool = False,
                                 repeat_message: str | None = "Please provide a selection to continue.") \
             -> list[SapioRecord]:
@@ -1438,12 +1445,12 @@ class CallbackUtil:
                                msg: str,
                                multi_select: bool = True,
                                only_key_fields: bool = False,
-                               search_types: list[SearchType] | None = None,
+                               search_types: Iterable[SearchType] | None = None,
                                scan_criteria: ScanToSelectCriteria | None = None,
                                custom_search: CustomReport | CustomReportCriteria | str | None = None,
-                               preselected_records: list[RecordIdentifier] | None = None,
-                               record_blacklist: list[RecordIdentifier] | None = None,
-                               record_whitelist: list[RecordIdentifier] | None = None,
+                               preselected_records: Iterable[RecordIdentifier] | None = None,
+                               record_blacklist: Iterable[RecordIdentifier] | None = None,
+                               record_whitelist: Iterable[RecordIdentifier] | None = None,
                                allow_creation: bool = False,
                                default_creation_number: int = 1,
                                *,
@@ -1533,7 +1540,7 @@ class CallbackUtil:
                      title: str,
                      msg: str,
                      show_comment: bool = True,
-                     additional_fields: list[AbstractVeloxFieldDefinition] | None = None,
+                     additional_fields: Iterable[AbstractVeloxFieldDefinition] | None = None,
                      *,
                      require_authentication: bool = False) -> ESigningResponsePojo:
         """
@@ -1572,7 +1579,7 @@ class CallbackUtil:
                                    popup_type=PopupType.Error)
         return response
 
-    def request_file(self, title: str, exts: list[str] | None = None,
+    def request_file(self, title: str, exts: Iterable[str] | None = None,
                      show_image_editor: bool = False, show_camera_button: bool = False) -> tuple[str, bytes]:
         """
         Request a single file from the user.
@@ -1605,7 +1612,7 @@ class CallbackUtil:
         self.__verify_file(file_path, sink.data, exts)
         return file_path, sink.data
 
-    def request_files(self, title: str, exts: list[str] | None = None,
+    def request_files(self, title: str, exts: Iterable[str] | None = None,
                       show_image_editor: bool = False, show_camera_button: bool = False) -> dict[str, bytes]:
         """
         Request multiple files from the user.
@@ -1637,7 +1644,7 @@ class CallbackUtil:
         return ret_dict
 
     @staticmethod
-    def __verify_file(file_path: str, file_bytes: bytes, allowed_extensions: list[str]) -> None:
+    def __verify_file(file_path: str, file_bytes: bytes, allowed_extensions: Iterable[str]) -> None:
         """
         Verify that the provided file was read (i.e. the file path and file bytes aren't None or empty) and that it
         has the correct file extension. Raises a user error exception if something about the file is incorrect.
@@ -1648,7 +1655,7 @@ class CallbackUtil:
         """
         if file_path is None or len(file_path) == 0 or file_bytes is None or len(file_bytes) == 0:
             raise SapioUserErrorException("Empty file provided or file unable to be read.")
-        if len(allowed_extensions) != 0:
+        if allowed_extensions:
             matches: bool = False
             for ext in allowed_extensions:
                 if file_path.endswith("." + ext.lstrip(".")):
@@ -1665,8 +1672,8 @@ class CallbackUtil:
         :param file_name: The name of the file.
         :param file_data: The data of the file, provided as either a string or as a bytes array.
         """
-        data = io.BytesIO(file_data.encode() if isinstance(file_data, str) else file_data)
-        self.callback.send_file(file_name, False, data)
+        with io.BytesIO(file_data.encode() if isinstance(file_data, str) else file_data) as data:
+            self.callback.send_file(file_name, False, data)
 
     def write_zip_file(self, zip_name: str, files: dict[str, str | bytes]) -> None:
         """
@@ -1675,12 +1682,12 @@ class CallbackUtil:
         :param zip_name: The name of the zip file.
         :param files: A dictionary of the files to add to the zip file.
         """
-        data = io.BytesIO(FileUtil.zip_files(files))
-        self.callback.send_file(zip_name, False, data)
+        with io.BytesIO(FileUtil.zip_files(files)) as data:
+            self.callback.send_file(zip_name, False, data)
 
     @staticmethod
     def __temp_dt_from_field_defs(data_type: DataTypeIdentifier, display_name: str | None,
-                                  plural_display_name: str | None, fields: list[AbstractVeloxFieldDefinition],
+                                  plural_display_name: str | None, fields: Iterable[AbstractVeloxFieldDefinition],
                                   column_positions: dict[str, tuple[int, int]] | None) -> TemporaryDataType:
         """
         Construct a Temporary Data Type definition from a provided list of field definitions for use in a callback.
@@ -1714,7 +1721,7 @@ class CallbackUtil:
             builder.add_field(field_def, column, span)
         return builder.get_temporary_data_type()
 
-    def __temp_dt_from_field_names(self, data_type: str, fields: list[FieldIdentifier | FieldFilterCriteria],
+    def __temp_dt_from_field_names(self, data_type: str, fields: Iterable[FieldIdentifier | FieldFilterCriteria],
                                    column_positions: dict[str, tuple[int, int]] | None,
                                    default_modifier: FieldModifier, field_modifiers: dict[str, FieldModifier]) \
             -> TemporaryDataType:
@@ -1731,6 +1738,7 @@ class CallbackUtil:
 
         # Determine if any FieldFilterCriteria were provided. If so, remove them from the fields list so that it
         # contains only field identifiers.
+        fields = list(fields)
         filter_criteria: list[FieldFilterCriteria] = [x for x in fields if isinstance(x, FieldFilterCriteria)]
         for criteria in filter_criteria:
             fields.remove(criteria)
@@ -1983,15 +1991,15 @@ class FieldFilterCriteria:
     key_field: bool | None
     identifier: bool | None
     system_field: bool | None
-    field_types: list[FieldType] | None
-    not_field_types: list[FieldType] | None
+    field_types: Container[FieldType] | None
+    not_field_types: Container[FieldType] | None
     matches_tag: str | None
     contains_tag: str | None
     regex_tag: str | re.Pattern[str] | None
 
     def __init__(self, *, required: bool | None = None, editable: bool | None = None, key_field: bool | None = None,
                  identifier: bool | None = None, system_field: bool | None = None,
-                 field_types: list[FieldType] | None = None, not_field_types: list[FieldType] | None = None,
+                 field_types: Container[FieldType] | None = None, not_field_types: Container[FieldType] | None = None,
                  matches_tag: str | None = None, contains_tag: str | None = None,
                  regex_tag: str | re.Pattern[str] | None = None):
         """

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/customreport/auto_pagers.py

@@ -6,6 +6,7 @@ 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
@@ -153,7 +154,7 @@ class _RecordReportPagerBase(SapioPyAutoPager[CustomReportCriteria, WrappedType
         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: list[int] = [row[id_index] for row in report.result_table]
+        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:

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/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]