sapiopycommons 2024.11.7a354__py3-none-any.whl → 2024.11.8a359__py3-none-any.whl

sapiopycommons/general/accession_service.py

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

sapiopycommons/general/audit_log.py

@@ -1,189 +0,0 @@
-from enum import Enum
-
-from sapiopylib.rest.User import SapioUser
-from sapiopylib.rest.pojo.CustomReport import ReportColumn, CustomReportCriteria
-
-from sapiopycommons.customreport.column_builder import ColumnBuilder
-from sapiopycommons.customreport.term_builder import TermBuilder
-from sapiopycommons.datatype.pseudo_data_types import AuditLogPseudoDef
-from sapiopycommons.general.aliases import RecordIdentifier, AliasUtil, UserIdentifier, FieldIdentifier, FieldValue
-from sapiopycommons.general.custom_report_util import CustomReportUtil
-
-
-class EventType(Enum):
-    """An enum to represent the possible event type values with the event type column in the audit log table."""
-    ADD = 0
-    DELETE = 1
-    MODIFY = 2
-    INFO = 3
-    ERROR = 4
-    WARNING = 5
-    IMPORT = 6
-    GENERATE = 7
-    EXPORT = 8
-    ADDREF = 9
-    REMOVEREF = 10
-    ESIGNATURE = 11
-    ROLEASSIGNMENT = 12
-
-
-class AuditLogEntry:
-    __event_type: EventType
-    __date: int
-    __data_type_name: str
-    __record_id: int
-    __description: str
-    __users_login_name: str
-    __comment: str
-    __data_record_name: str
-    __data_field_name: str
-    __original_value: str
-    __new_value: str
-
-    @property
-    def event_type(self) -> EventType:
-        return self.__event_type
-
-    @property
-    def date(self) -> int:
-        return self.__date
-
-    @property
-    def data_type_name(self) -> str:
-        return self.__data_type_name
-
-    @property
-    def record_id(self) -> int:
-        return self.__record_id
-
-    @property
-    def description(self) -> str:
-        return self.__description
-
-    @property
-    def users_login_name(self) -> str:
-        return self.__users_login_name
-
-    @property
-    def comment(self) -> str:
-        return self.__comment
-
-    @property
-    def data_record_name(self) -> str:
-        return self.__data_record_name
-
-    @property
-    def data_field_name(self) -> str:
-        return self.__data_field_name
-
-    @property
-    def original_value(self) -> str:
-        return self.__original_value
-
-    @property
-    def new_value(self) -> str:
-        return self.__new_value
-
-    def __init__(self, report_row: dict[str, FieldValue]):
-        self.__event_type = EventType((report_row[AuditLogPseudoDef.EVENT_TYPE__FIELD_NAME.field_name]))
-        self.__date = report_row[AuditLogPseudoDef.TIME_STAMP__FIELD_NAME.field_name]
-        self.__data_type_name = report_row[AuditLogPseudoDef.DATA_TYPE_NAME__FIELD_NAME.field_name]
-        self.__record_id = report_row[AuditLogPseudoDef.RECORD_ID__FIELD_NAME.field_name]
-        self.__description = report_row[AuditLogPseudoDef.DESCRIPTION__FIELD_NAME.field_name]
-        self.__users_login_name = report_row[AuditLogPseudoDef.USER_NAME__FIELD_NAME.field_name]
-        self.__comment = report_row[AuditLogPseudoDef.USER_COMMENT__FIELD_NAME.field_name]
-        self.__data_record_name = report_row[AuditLogPseudoDef.RECORD_NAME__FIELD_NAME]
-        self.__data_field_name = report_row[AuditLogPseudoDef.DATA_FIELD_NAME__FIELD_NAME.field_name]
-        self.__original_value = report_row[AuditLogPseudoDef.ORIGINAL_VALUE__FIELD_NAME.field_name]
-        self.__new_value = report_row[AuditLogPseudoDef.NEW_VALUE__FIELD_NAME.field_name]
-
-
-class AuditLogUtil:
-    user: SapioUser
-
-    def __init__(self, context: UserIdentifier):
-        self.user = AliasUtil.to_sapio_user(context)
-
-    @staticmethod
-    def report_columns() -> list[ReportColumn]:
-        return [
-            ColumnBuilder.build_column(AuditLogPseudoDef.DATA_TYPE_NAME, AuditLogPseudoDef.EVENT_TYPE__FIELD_NAME),
-            ColumnBuilder.build_column(AuditLogPseudoDef.DATA_TYPE_NAME, AuditLogPseudoDef.TIME_STAMP__FIELD_NAME),
-            ColumnBuilder.build_column(AuditLogPseudoDef.DATA_TYPE_NAME, AuditLogPseudoDef.DATA_TYPE_NAME__FIELD_NAME),
-            ColumnBuilder.build_column(AuditLogPseudoDef.DATA_TYPE_NAME, AuditLogPseudoDef.RECORD_ID__FIELD_NAME),
-            ColumnBuilder.build_column(AuditLogPseudoDef.DATA_TYPE_NAME, AuditLogPseudoDef.DESCRIPTION__FIELD_NAME),
-            ColumnBuilder.build_column(AuditLogPseudoDef.DATA_TYPE_NAME, AuditLogPseudoDef.USER_NAME__FIELD_NAME),
-            ColumnBuilder.build_column(AuditLogPseudoDef.DATA_TYPE_NAME, AuditLogPseudoDef.USER_COMMENT__FIELD_NAME),
-            ColumnBuilder.build_column(AuditLogPseudoDef.DATA_TYPE_NAME, AuditLogPseudoDef.RECORD_NAME__FIELD_NAME),
-            ColumnBuilder.build_column(AuditLogPseudoDef.DATA_TYPE_NAME, AuditLogPseudoDef.DATA_FIELD_NAME__FIELD_NAME),
-            ColumnBuilder.build_column(AuditLogPseudoDef.DATA_TYPE_NAME, AuditLogPseudoDef.ORIGINAL_VALUE__FIELD_NAME),
-            ColumnBuilder.build_column(AuditLogPseudoDef.DATA_TYPE_NAME, AuditLogPseudoDef.NEW_VALUE__FIELD_NAME)
-        ]
-
-    @staticmethod
-    def create_data_record_audit_log_report(records: list[RecordIdentifier],
-                                            fields: list[FieldIdentifier] | None = None) -> CustomReportCriteria:
-        """
-        This method creates a CustomReportCriteria object for running an audit log query based on data records.
-
-        Creates a CustomReportCriteria object with a query term based on the record ids/records passed into the method.
-        Optionally, the fields parameter can be populated to limit the search to particular fields. If the fields
-        parameter is not populated, the search will include results for all field changes.
-
-        :param records: The DataRecords, RecordModels, or record ids to base the search on.
-        :param fields: The data field names to include changes for.
-        :return: The constructed CustomReportCriteria object, which can be used to run a report on the audit log.
-        """
-        # Build the raw report term querying for any entry with a matching record ID value to the record ID's
-        # passed in.
-        record_ids = AliasUtil.to_record_ids(records)
-        root_term = TermBuilder.is_term(AuditLogPseudoDef.DATA_TYPE_NAME,
-                                        AuditLogPseudoDef.RECORD_ID__FIELD_NAME,
-                                        record_ids)
-
-        # If the user passed in any specific fields, then we should limit the query to those fields.
-        if fields:
-            fields: list[str] = AliasUtil.to_data_field_names(fields)
-            field_term = TermBuilder.is_term(AuditLogPseudoDef.DATA_TYPE_NAME,
-                                             AuditLogPseudoDef.DATA_FIELD_NAME__FIELD_NAME,
-                                             fields)
-            root_term = TermBuilder.and_terms(root_term, field_term)
-
-        return CustomReportCriteria(AuditLogUtil.report_columns(), root_term)
-
-    def run_data_record_audit_log_report(self, records: list[RecordIdentifier],
-                                         fields: list[FieldIdentifier] | None = None) \
-            -> dict[RecordIdentifier, list[AuditLogEntry]]:
-        """
-        This method runs a custom report for changes made to the given data records using the audit log.
-        See "create_data_record_audit_log_report" for more details about the data record audit log report.
-
-        :param records: The DataRecords, RecordModels, or record ids to base the search on.
-        :param fields: The data field names to include changes for.
-        :return: A dictionary where the keys are the record identifiers passed in, and the values are a list of
-            AuditLogEntry objects which match the record id value of those records.
-        """
-        fields: list[str] = AliasUtil.to_data_field_names(fields)
-        # First, we must build our report criteria for running the Custom Report.
-        criteria = AuditLogUtil.create_data_record_audit_log_report(records, fields)
-
-        # Then we must run the custom report using that criteria.
-        raw_report_data: list[dict[str, FieldValue]] = CustomReportUtil.run_custom_report(self.user, criteria)
-
-        # This section will prepare a map matching the original RecordIdentifier by record id.
-        # This is because the audit log entries will have record ids, but we want the keys in our result map
-        # to match the record identifiers that the user passed in, for convenience.
-        record_identifier_mapping: dict[int, RecordIdentifier] = dict()
-        for record in records:
-            record_id = AliasUtil.to_record_id(record)
-            record_identifier_mapping[record_id] = record
-
-        # Finally, we compile our audit data into a map where the keys are the record identifiers passed in,
-        # and the value is a list of applicable audit log entries.
-        final_audit_data: dict[RecordIdentifier, list[AuditLogEntry]] = dict()
-        for audit_entry_data in raw_report_data:
-            audit_entry: AuditLogEntry = AuditLogEntry(audit_entry_data)
-            identifier: RecordIdentifier = record_identifier_mapping.get(audit_entry.record_id)
-            final_audit_data.setdefault(identifier, []).append(audit_entry)
-
-        return final_audit_data

sapiopycommons/general/sapio_links.py

@@ -1,50 +0,0 @@
-from sapiopylib.rest.User import SapioUser
-from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
-
-from sapiopycommons.general.aliases import RecordIdentifier, ExperimentIdentifier, AliasUtil, DataTypeIdentifier
-from sapiopycommons.general.exceptions import SapioException
-
-
-class SapioNavigationLinker:
-    """
-    Given a URL to a system's webservice API (example: https://company.exemplareln.com/webservice/api), construct
-    URLs for navigation links to various locations in the system.
-    """
-    base_url: str
-
-    def __init__(self, url: str | SapioUser | SapioWebhookContext):
-        """
-        :param url: A user or context object that is being used to send requests to a Sapio system, or a URL to a
-            system's webservice API.
-        """
-        if isinstance(url, SapioWebhookContext):
-            url = url.user.url
-        elif isinstance(url, SapioUser):
-            url = url.url
-        self.base_url = url.rstrip("/").replace('webservice/api', 'veloxClient')
-
-    def data_record(self, record_identifier: RecordIdentifier, data_type_name: DataTypeIdentifier | None = None) -> str:
-        """
-        :param record_identifier: An object that can be used to identify a record in the system, be that a record ID,
-            a data record, or a record model.
-        :param data_type_name: If the provided record identifier is a record ID, then the data type name of the record
-            must be provided in this parameter. Otherwise, this parameter is ignored.
-        :return: A URL for navigating to the input record.
-        """
-        record_id: int = AliasUtil.to_record_id(record_identifier)
-        if data_type_name:
-            data_type_name = AliasUtil.to_data_type_name(data_type_name)
-        if not isinstance(record_identifier, int):
-            data_type_name = AliasUtil.to_data_type_name(record_identifier)
-        if not data_type_name:
-            raise SapioException("Unable to create a data record link without a data type name. "
-                                 "Only a record ID was provided.")
-        return self.base_url + f"/#dataType={data_type_name};recordId={record_id};view=dataRecord"
-
-    def experiment(self, experiment: ExperimentIdentifier) -> str:
-        """
-        :param experiment: An object that can be used to identify an experiment in the system, be that an experiment
-            object, experiment protocol, or a notebook ID.
-        :return: A URL for navigating to the input experiment.
-        """
-        return self.base_url + f"/#notebookExperimentId={AliasUtil.to_notebook_id(experiment)};view=eln"