sapiopycommons 2025.4.8a474__py3-none-any.whl → 2025.4.9a150__py3-none-any.whl

{sapiopycommons-2025.4.8a474.dist-info → sapiopycommons-2025.4.9a150.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sapiopycommons
-Version: 2025.4.8a474
+Version: 2025.4.9a150
 Summary: Official Sapio Python API Utilities Package
 Project-URL: Homepage, https://github.com/sapiosciences
 Author-email: Jonathan Steck <jsteck@sapiosciences.com>, Yechen Qiao <yqiao@sapiosciences.com>

sapiopycommons-2025.4.9a150.dist-info/RECORD

@@ -0,0 +1,59 @@
+sapiopycommons/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sapiopycommons/callbacks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sapiopycommons/callbacks/callback_util.py,sha256=2pGr14f_FVCqeF6dsbYP1e4cOsaUTQyQ7XVwZuUkM_k,67952
+sapiopycommons/callbacks/field_builder.py,sha256=p2XacN99MuKk3ite8GAqstUMpixqugul2CsC4gB83-o,38620
+sapiopycommons/chem/IndigoMolecules.py,sha256=slM2y39zZFHc468c366EqR8T-GYJ24UnM9HWAqWFEwQ,3900
+sapiopycommons/chem/Molecules.py,sha256=9B4sbwbvYs50XHRn0TZiu-D1Oa3pKrI9qE5vNW8zv-U,12464
+sapiopycommons/chem/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sapiopycommons/customreport/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sapiopycommons/customreport/column_builder.py,sha256=0RO53e9rKPZ07C--KcepN6_tpRw_FxF3O9vdG0ilKG8,3014
+sapiopycommons/customreport/custom_report_builder.py,sha256=BlTxZ4t1sfZA2Ciur1EfYvkZxHxJ7ADwYNAe2zwiN0c,7176
+sapiopycommons/customreport/term_builder.py,sha256=PNp71NF1vFxidk5v6uQNi9oQR9KJIk8WfhyntvvZN-U,18573
+sapiopycommons/datatype/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sapiopycommons/datatype/attachment_util.py,sha256=_l2swuP8noIGAl4bwzBUEhr6YlN_OVZl3-gi1XqFHYA,3364
+sapiopycommons/datatype/data_fields.py,sha256=g8Ib6LH8ikNu9AzeVJs8Z2qS8A-cplACeFU7vYguNEY,4063
+sapiopycommons/datatype/pseudo_data_types.py,sha256=6TG7aJxgmUZ8FQkWBcgmbK5oy7AFFNtKOPpi1w1OOYA,27657
+sapiopycommons/eln/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sapiopycommons/eln/experiment_handler.py,sha256=ZSx0uZy-2OtH_ArHy2OVwoNI3BYQLXSHGBmjviZl1Fw,69283
+sapiopycommons/eln/experiment_report_util.py,sha256=bs9zSUgRo40q2VYtjDCVPsT-D1umdNfl5s4oZrY4uuc,36597
+sapiopycommons/eln/plate_designer.py,sha256=FYJfhhNq8hdfuXgDYOYHy6g0m2zNwQXZWF_MTPzElDg,7184
+sapiopycommons/files/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sapiopycommons/files/complex_data_loader.py,sha256=T39veNhvYl6j_uZjIIJ8Mk5Aa7otR5RB-g8XlAdkksA,1421
+sapiopycommons/files/file_bridge.py,sha256=WwCVegk0OGA8eqho8chsOsLlqg1nXctO75zfh-rHF-g,5950
+sapiopycommons/files/file_bridge_handler.py,sha256=bt2IfIsxJ4lcJYo_NHvCQ17ZV6C4fSAEa8Zcgixh7B4,14263
+sapiopycommons/files/file_data_handler.py,sha256=SCsjODMJIPEBSsahzXUeOM7CfSCmYwPPoGAM6aOfelo,36743
+sapiopycommons/files/file_util.py,sha256=wbL3rxcFc-t2mXaPWWkoFWYGopvTcQts9Wf-L5GkhT8,29498
+sapiopycommons/files/file_validator.py,sha256=4OvY98ueJWPJdpndwnKv2nqVvLP9S2W7Il_dM0Y0ojo,28709
+sapiopycommons/files/file_writer.py,sha256=96Xl8TTT46Krxe_J8rmmlEMtel4nzZB961f5Yqtl1-I,17616
+sapiopycommons/flowcyto/flow_cyto.py,sha256=YlkKJR_zEHYRuNW0bnTqlTyZeXs0lOaeSCfG2fnfD7E,3227
+sapiopycommons/flowcyto/flowcyto_data.py,sha256=mYKFuLbtpJ-EsQxLGtu4tNHVlygTxKixgJxJqD68F58,2596
+sapiopycommons/general/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sapiopycommons/general/accession_service.py,sha256=HYgyOsH_UaoRnoury-c2yTW8SeG4OtjLemdpCzoV4R8,13484
+sapiopycommons/general/aliases.py,sha256=tdDBNWSGx6s39eHJ3n2kscc4xxW3ZYaUfDftct6FmJE,12910
+sapiopycommons/general/audit_log.py,sha256=pvXPfLr4Rw2X52wAXJGsX5fsPllswnCqaFZQ181j_GU,8727
+sapiopycommons/general/custom_report_util.py,sha256=6ZIg_Jl02TYUygfc5xqBoI1srPsSxLyxaJ9jwTolGcM,16671
+sapiopycommons/general/exceptions.py,sha256=GY7fe0qOgoy4kQVn_Pn3tdzHsJZyNIpa6VCChg6tzuM,1813
+sapiopycommons/general/popup_util.py,sha256=L-4qpTemSZdlD6_6oEsDYIzLOCiZgDK6wC6DqUwzOYA,31925
+sapiopycommons/general/sapio_links.py,sha256=o9Z-8y2rz6AI0Cy6tq58ElPge9RBnisGc9NyccbaJxs,2610
+sapiopycommons/general/storage_util.py,sha256=ovmK_jN7v09BoX07XxwShpBUC5WYQOM7dbKV_VeLXJU,8892
+sapiopycommons/general/time_util.py,sha256=jU1urPoZRv6evNucR0-288EyT4PrsDpCr-H1-7BKq9A,12363
+sapiopycommons/multimodal/multimodal.py,sha256=A1QsC8QTPmgZyPr7KtMbPRedn2Ie4WIErodUvQ9otgU,6724
+sapiopycommons/multimodal/multimodal_data.py,sha256=0BeVPr9HaC0hNTF1v1phTIKGruvNnwerHsD994qJKBg,15099
+sapiopycommons/processtracking/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sapiopycommons/processtracking/custom_workflow_handler.py,sha256=B8KxQlwlLGkxnEid2jb9igGyGqrtcsBMhcOb9MfnO9E,23465
+sapiopycommons/processtracking/endpoints.py,sha256=w5bziI2xC7450M95rCF8JpRwkoni1kEDibyAux9B12Q,10848
+sapiopycommons/recordmodel/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sapiopycommons/recordmodel/record_handler.py,sha256=5kCO5zsSg0kp3uYpgw1vf0WLHw30pMNC_6Bn3G7iQkI,64796
+sapiopycommons/rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sapiopycommons/rules/eln_rule_handler.py,sha256=JYzDA_14D2nLnlqwbpIxVOrfKWzbOS27AYf4TQfGr4Q,10469
+sapiopycommons/rules/on_save_rule_handler.py,sha256=Rkqvph20RbNq6m-RF4fbvCP-YfD2CZYBM2iTr3nl0eY,10236
+sapiopycommons/sftpconnect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sapiopycommons/sftpconnect/sftp_builder.py,sha256=lFK3FeXk-sFLefW0hqY8WGUQDeYiGaT6yDACzT_zFgQ,3015
+sapiopycommons/webhook/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sapiopycommons/webhook/webhook_context.py,sha256=D793uLsb1691SalaPnBUk3rOSxn_hYLhdvkaIxjNXss,1909
+sapiopycommons/webhook/webhook_handlers.py,sha256=MdsVK4bHffkMNmNWl0_qvu-5Lz8-qGu4Ryi7lZO1BZs,18586
+sapiopycommons/webhook/webservice_handlers.py,sha256=Y5dHx_UFWFuSqaoPL6Re-fsKYRuxvCWZ8bj6KSZ3jfM,14285
+sapiopycommons-2025.4.9a150.dist-info/METADATA,sha256=5O99CwAKXRdS1K_CNvmlDcEB68rcd-FkTOf-uzkKDUg,3142
+sapiopycommons-2025.4.9a150.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+sapiopycommons-2025.4.9a150.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
+sapiopycommons-2025.4.9a150.dist-info/RECORD,,

sapiopycommons/customreport/auto_pagers.py

@@ -1,281 +0,0 @@
-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/eln/experiment_cache.py

@@ -1,173 +0,0 @@
-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]